// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: protobuf/pg_query.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_protobuf_2fpg_5fquery_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protobuf_2fpg_5fquery_2eproto

#include <limits>
#include <string>

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

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

// Internal implementation detail -- do not use these members.
struct TableStruct_protobuf_2fpg_5fquery_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[233]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protobuf_2fpg_5fquery_2eproto;
namespace pg_query {
class A_ArrayExpr;
class A_ArrayExprDefaultTypeInternal;
extern A_ArrayExprDefaultTypeInternal _A_ArrayExpr_default_instance_;
class A_Const;
class A_ConstDefaultTypeInternal;
extern A_ConstDefaultTypeInternal _A_Const_default_instance_;
class A_Expr;
class A_ExprDefaultTypeInternal;
extern A_ExprDefaultTypeInternal _A_Expr_default_instance_;
class A_Indices;
class A_IndicesDefaultTypeInternal;
extern A_IndicesDefaultTypeInternal _A_Indices_default_instance_;
class A_Indirection;
class A_IndirectionDefaultTypeInternal;
extern A_IndirectionDefaultTypeInternal _A_Indirection_default_instance_;
class A_Star;
class A_StarDefaultTypeInternal;
extern A_StarDefaultTypeInternal _A_Star_default_instance_;
class AccessPriv;
class AccessPrivDefaultTypeInternal;
extern AccessPrivDefaultTypeInternal _AccessPriv_default_instance_;
class Aggref;
class AggrefDefaultTypeInternal;
extern AggrefDefaultTypeInternal _Aggref_default_instance_;
class Alias;
class AliasDefaultTypeInternal;
extern AliasDefaultTypeInternal _Alias_default_instance_;
class AlterCollationStmt;
class AlterCollationStmtDefaultTypeInternal;
extern AlterCollationStmtDefaultTypeInternal _AlterCollationStmt_default_instance_;
class AlterDatabaseSetStmt;
class AlterDatabaseSetStmtDefaultTypeInternal;
extern AlterDatabaseSetStmtDefaultTypeInternal _AlterDatabaseSetStmt_default_instance_;
class AlterDatabaseStmt;
class AlterDatabaseStmtDefaultTypeInternal;
extern AlterDatabaseStmtDefaultTypeInternal _AlterDatabaseStmt_default_instance_;
class AlterDefaultPrivilegesStmt;
class AlterDefaultPrivilegesStmtDefaultTypeInternal;
extern AlterDefaultPrivilegesStmtDefaultTypeInternal _AlterDefaultPrivilegesStmt_default_instance_;
class AlterDomainStmt;
class AlterDomainStmtDefaultTypeInternal;
extern AlterDomainStmtDefaultTypeInternal _AlterDomainStmt_default_instance_;
class AlterEnumStmt;
class AlterEnumStmtDefaultTypeInternal;
extern AlterEnumStmtDefaultTypeInternal _AlterEnumStmt_default_instance_;
class AlterEventTrigStmt;
class AlterEventTrigStmtDefaultTypeInternal;
extern AlterEventTrigStmtDefaultTypeInternal _AlterEventTrigStmt_default_instance_;
class AlterExtensionContentsStmt;
class AlterExtensionContentsStmtDefaultTypeInternal;
extern AlterExtensionContentsStmtDefaultTypeInternal _AlterExtensionContentsStmt_default_instance_;
class AlterExtensionStmt;
class AlterExtensionStmtDefaultTypeInternal;
extern AlterExtensionStmtDefaultTypeInternal _AlterExtensionStmt_default_instance_;
class AlterFdwStmt;
class AlterFdwStmtDefaultTypeInternal;
extern AlterFdwStmtDefaultTypeInternal _AlterFdwStmt_default_instance_;
class AlterForeignServerStmt;
class AlterForeignServerStmtDefaultTypeInternal;
extern AlterForeignServerStmtDefaultTypeInternal _AlterForeignServerStmt_default_instance_;
class AlterFunctionStmt;
class AlterFunctionStmtDefaultTypeInternal;
extern AlterFunctionStmtDefaultTypeInternal _AlterFunctionStmt_default_instance_;
class AlterObjectDependsStmt;
class AlterObjectDependsStmtDefaultTypeInternal;
extern AlterObjectDependsStmtDefaultTypeInternal _AlterObjectDependsStmt_default_instance_;
class AlterObjectSchemaStmt;
class AlterObjectSchemaStmtDefaultTypeInternal;
extern AlterObjectSchemaStmtDefaultTypeInternal _AlterObjectSchemaStmt_default_instance_;
class AlterOpFamilyStmt;
class AlterOpFamilyStmtDefaultTypeInternal;
extern AlterOpFamilyStmtDefaultTypeInternal _AlterOpFamilyStmt_default_instance_;
class AlterOperatorStmt;
class AlterOperatorStmtDefaultTypeInternal;
extern AlterOperatorStmtDefaultTypeInternal _AlterOperatorStmt_default_instance_;
class AlterOwnerStmt;
class AlterOwnerStmtDefaultTypeInternal;
extern AlterOwnerStmtDefaultTypeInternal _AlterOwnerStmt_default_instance_;
class AlterPolicyStmt;
class AlterPolicyStmtDefaultTypeInternal;
extern AlterPolicyStmtDefaultTypeInternal _AlterPolicyStmt_default_instance_;
class AlterPublicationStmt;
class AlterPublicationStmtDefaultTypeInternal;
extern AlterPublicationStmtDefaultTypeInternal _AlterPublicationStmt_default_instance_;
class AlterRoleSetStmt;
class AlterRoleSetStmtDefaultTypeInternal;
extern AlterRoleSetStmtDefaultTypeInternal _AlterRoleSetStmt_default_instance_;
class AlterRoleStmt;
class AlterRoleStmtDefaultTypeInternal;
extern AlterRoleStmtDefaultTypeInternal _AlterRoleStmt_default_instance_;
class AlterSeqStmt;
class AlterSeqStmtDefaultTypeInternal;
extern AlterSeqStmtDefaultTypeInternal _AlterSeqStmt_default_instance_;
class AlterStatsStmt;
class AlterStatsStmtDefaultTypeInternal;
extern AlterStatsStmtDefaultTypeInternal _AlterStatsStmt_default_instance_;
class AlterSubscriptionStmt;
class AlterSubscriptionStmtDefaultTypeInternal;
extern AlterSubscriptionStmtDefaultTypeInternal _AlterSubscriptionStmt_default_instance_;
class AlterSystemStmt;
class AlterSystemStmtDefaultTypeInternal;
extern AlterSystemStmtDefaultTypeInternal _AlterSystemStmt_default_instance_;
class AlterTSConfigurationStmt;
class AlterTSConfigurationStmtDefaultTypeInternal;
extern AlterTSConfigurationStmtDefaultTypeInternal _AlterTSConfigurationStmt_default_instance_;
class AlterTSDictionaryStmt;
class AlterTSDictionaryStmtDefaultTypeInternal;
extern AlterTSDictionaryStmtDefaultTypeInternal _AlterTSDictionaryStmt_default_instance_;
class AlterTableCmd;
class AlterTableCmdDefaultTypeInternal;
extern AlterTableCmdDefaultTypeInternal _AlterTableCmd_default_instance_;
class AlterTableMoveAllStmt;
class AlterTableMoveAllStmtDefaultTypeInternal;
extern AlterTableMoveAllStmtDefaultTypeInternal _AlterTableMoveAllStmt_default_instance_;
class AlterTableSpaceOptionsStmt;
class AlterTableSpaceOptionsStmtDefaultTypeInternal;
extern AlterTableSpaceOptionsStmtDefaultTypeInternal _AlterTableSpaceOptionsStmt_default_instance_;
class AlterTableStmt;
class AlterTableStmtDefaultTypeInternal;
extern AlterTableStmtDefaultTypeInternal _AlterTableStmt_default_instance_;
class AlterTypeStmt;
class AlterTypeStmtDefaultTypeInternal;
extern AlterTypeStmtDefaultTypeInternal _AlterTypeStmt_default_instance_;
class AlterUserMappingStmt;
class AlterUserMappingStmtDefaultTypeInternal;
extern AlterUserMappingStmtDefaultTypeInternal _AlterUserMappingStmt_default_instance_;
class AlternativeSubPlan;
class AlternativeSubPlanDefaultTypeInternal;
extern AlternativeSubPlanDefaultTypeInternal _AlternativeSubPlan_default_instance_;
class ArrayCoerceExpr;
class ArrayCoerceExprDefaultTypeInternal;
extern ArrayCoerceExprDefaultTypeInternal _ArrayCoerceExpr_default_instance_;
class ArrayExpr;
class ArrayExprDefaultTypeInternal;
extern ArrayExprDefaultTypeInternal _ArrayExpr_default_instance_;
class BitString;
class BitStringDefaultTypeInternal;
extern BitStringDefaultTypeInternal _BitString_default_instance_;
class Bitmapset;
class BitmapsetDefaultTypeInternal;
extern BitmapsetDefaultTypeInternal _Bitmapset_default_instance_;
class BoolExpr;
class BoolExprDefaultTypeInternal;
extern BoolExprDefaultTypeInternal _BoolExpr_default_instance_;
class BooleanTest;
class BooleanTestDefaultTypeInternal;
extern BooleanTestDefaultTypeInternal _BooleanTest_default_instance_;
class CallContext;
class CallContextDefaultTypeInternal;
extern CallContextDefaultTypeInternal _CallContext_default_instance_;
class CallStmt;
class CallStmtDefaultTypeInternal;
extern CallStmtDefaultTypeInternal _CallStmt_default_instance_;
class CaseExpr;
class CaseExprDefaultTypeInternal;
extern CaseExprDefaultTypeInternal _CaseExpr_default_instance_;
class CaseTestExpr;
class CaseTestExprDefaultTypeInternal;
extern CaseTestExprDefaultTypeInternal _CaseTestExpr_default_instance_;
class CaseWhen;
class CaseWhenDefaultTypeInternal;
extern CaseWhenDefaultTypeInternal _CaseWhen_default_instance_;
class CheckPointStmt;
class CheckPointStmtDefaultTypeInternal;
extern CheckPointStmtDefaultTypeInternal _CheckPointStmt_default_instance_;
class ClosePortalStmt;
class ClosePortalStmtDefaultTypeInternal;
extern ClosePortalStmtDefaultTypeInternal _ClosePortalStmt_default_instance_;
class ClusterStmt;
class ClusterStmtDefaultTypeInternal;
extern ClusterStmtDefaultTypeInternal _ClusterStmt_default_instance_;
class CoalesceExpr;
class CoalesceExprDefaultTypeInternal;
extern CoalesceExprDefaultTypeInternal _CoalesceExpr_default_instance_;
class CoerceToDomain;
class CoerceToDomainDefaultTypeInternal;
extern CoerceToDomainDefaultTypeInternal _CoerceToDomain_default_instance_;
class CoerceToDomainValue;
class CoerceToDomainValueDefaultTypeInternal;
extern CoerceToDomainValueDefaultTypeInternal _CoerceToDomainValue_default_instance_;
class CoerceViaIO;
class CoerceViaIODefaultTypeInternal;
extern CoerceViaIODefaultTypeInternal _CoerceViaIO_default_instance_;
class CollateClause;
class CollateClauseDefaultTypeInternal;
extern CollateClauseDefaultTypeInternal _CollateClause_default_instance_;
class CollateExpr;
class CollateExprDefaultTypeInternal;
extern CollateExprDefaultTypeInternal _CollateExpr_default_instance_;
class ColumnDef;
class ColumnDefDefaultTypeInternal;
extern ColumnDefDefaultTypeInternal _ColumnDef_default_instance_;
class ColumnRef;
class ColumnRefDefaultTypeInternal;
extern ColumnRefDefaultTypeInternal _ColumnRef_default_instance_;
class CommentStmt;
class CommentStmtDefaultTypeInternal;
extern CommentStmtDefaultTypeInternal _CommentStmt_default_instance_;
class CommonTableExpr;
class CommonTableExprDefaultTypeInternal;
extern CommonTableExprDefaultTypeInternal _CommonTableExpr_default_instance_;
class CompositeTypeStmt;
class CompositeTypeStmtDefaultTypeInternal;
extern CompositeTypeStmtDefaultTypeInternal _CompositeTypeStmt_default_instance_;
class Constraint;
class ConstraintDefaultTypeInternal;
extern ConstraintDefaultTypeInternal _Constraint_default_instance_;
class ConstraintsSetStmt;
class ConstraintsSetStmtDefaultTypeInternal;
extern ConstraintsSetStmtDefaultTypeInternal _ConstraintsSetStmt_default_instance_;
class ConvertRowtypeExpr;
class ConvertRowtypeExprDefaultTypeInternal;
extern ConvertRowtypeExprDefaultTypeInternal _ConvertRowtypeExpr_default_instance_;
class CopyStmt;
class CopyStmtDefaultTypeInternal;
extern CopyStmtDefaultTypeInternal _CopyStmt_default_instance_;
class CreateAmStmt;
class CreateAmStmtDefaultTypeInternal;
extern CreateAmStmtDefaultTypeInternal _CreateAmStmt_default_instance_;
class CreateCastStmt;
class CreateCastStmtDefaultTypeInternal;
extern CreateCastStmtDefaultTypeInternal _CreateCastStmt_default_instance_;
class CreateConversionStmt;
class CreateConversionStmtDefaultTypeInternal;
extern CreateConversionStmtDefaultTypeInternal _CreateConversionStmt_default_instance_;
class CreateDomainStmt;
class CreateDomainStmtDefaultTypeInternal;
extern CreateDomainStmtDefaultTypeInternal _CreateDomainStmt_default_instance_;
class CreateEnumStmt;
class CreateEnumStmtDefaultTypeInternal;
extern CreateEnumStmtDefaultTypeInternal _CreateEnumStmt_default_instance_;
class CreateEventTrigStmt;
class CreateEventTrigStmtDefaultTypeInternal;
extern CreateEventTrigStmtDefaultTypeInternal _CreateEventTrigStmt_default_instance_;
class CreateExtensionStmt;
class CreateExtensionStmtDefaultTypeInternal;
extern CreateExtensionStmtDefaultTypeInternal _CreateExtensionStmt_default_instance_;
class CreateFdwStmt;
class CreateFdwStmtDefaultTypeInternal;
extern CreateFdwStmtDefaultTypeInternal _CreateFdwStmt_default_instance_;
class CreateForeignServerStmt;
class CreateForeignServerStmtDefaultTypeInternal;
extern CreateForeignServerStmtDefaultTypeInternal _CreateForeignServerStmt_default_instance_;
class CreateForeignTableStmt;
class CreateForeignTableStmtDefaultTypeInternal;
extern CreateForeignTableStmtDefaultTypeInternal _CreateForeignTableStmt_default_instance_;
class CreateFunctionStmt;
class CreateFunctionStmtDefaultTypeInternal;
extern CreateFunctionStmtDefaultTypeInternal _CreateFunctionStmt_default_instance_;
class CreateOpClassItem;
class CreateOpClassItemDefaultTypeInternal;
extern CreateOpClassItemDefaultTypeInternal _CreateOpClassItem_default_instance_;
class CreateOpClassStmt;
class CreateOpClassStmtDefaultTypeInternal;
extern CreateOpClassStmtDefaultTypeInternal _CreateOpClassStmt_default_instance_;
class CreateOpFamilyStmt;
class CreateOpFamilyStmtDefaultTypeInternal;
extern CreateOpFamilyStmtDefaultTypeInternal _CreateOpFamilyStmt_default_instance_;
class CreatePLangStmt;
class CreatePLangStmtDefaultTypeInternal;
extern CreatePLangStmtDefaultTypeInternal _CreatePLangStmt_default_instance_;
class CreatePolicyStmt;
class CreatePolicyStmtDefaultTypeInternal;
extern CreatePolicyStmtDefaultTypeInternal _CreatePolicyStmt_default_instance_;
class CreatePublicationStmt;
class CreatePublicationStmtDefaultTypeInternal;
extern CreatePublicationStmtDefaultTypeInternal _CreatePublicationStmt_default_instance_;
class CreateRangeStmt;
class CreateRangeStmtDefaultTypeInternal;
extern CreateRangeStmtDefaultTypeInternal _CreateRangeStmt_default_instance_;
class CreateRoleStmt;
class CreateRoleStmtDefaultTypeInternal;
extern CreateRoleStmtDefaultTypeInternal _CreateRoleStmt_default_instance_;
class CreateSchemaStmt;
class CreateSchemaStmtDefaultTypeInternal;
extern CreateSchemaStmtDefaultTypeInternal _CreateSchemaStmt_default_instance_;
class CreateSeqStmt;
class CreateSeqStmtDefaultTypeInternal;
extern CreateSeqStmtDefaultTypeInternal _CreateSeqStmt_default_instance_;
class CreateStatsStmt;
class CreateStatsStmtDefaultTypeInternal;
extern CreateStatsStmtDefaultTypeInternal _CreateStatsStmt_default_instance_;
class CreateStmt;
class CreateStmtDefaultTypeInternal;
extern CreateStmtDefaultTypeInternal _CreateStmt_default_instance_;
class CreateSubscriptionStmt;
class CreateSubscriptionStmtDefaultTypeInternal;
extern CreateSubscriptionStmtDefaultTypeInternal _CreateSubscriptionStmt_default_instance_;
class CreateTableAsStmt;
class CreateTableAsStmtDefaultTypeInternal;
extern CreateTableAsStmtDefaultTypeInternal _CreateTableAsStmt_default_instance_;
class CreateTableSpaceStmt;
class CreateTableSpaceStmtDefaultTypeInternal;
extern CreateTableSpaceStmtDefaultTypeInternal _CreateTableSpaceStmt_default_instance_;
class CreateTransformStmt;
class CreateTransformStmtDefaultTypeInternal;
extern CreateTransformStmtDefaultTypeInternal _CreateTransformStmt_default_instance_;
class CreateTrigStmt;
class CreateTrigStmtDefaultTypeInternal;
extern CreateTrigStmtDefaultTypeInternal _CreateTrigStmt_default_instance_;
class CreateUserMappingStmt;
class CreateUserMappingStmtDefaultTypeInternal;
extern CreateUserMappingStmtDefaultTypeInternal _CreateUserMappingStmt_default_instance_;
class CreatedbStmt;
class CreatedbStmtDefaultTypeInternal;
extern CreatedbStmtDefaultTypeInternal _CreatedbStmt_default_instance_;
class CurrentOfExpr;
class CurrentOfExprDefaultTypeInternal;
extern CurrentOfExprDefaultTypeInternal _CurrentOfExpr_default_instance_;
class DeallocateStmt;
class DeallocateStmtDefaultTypeInternal;
extern DeallocateStmtDefaultTypeInternal _DeallocateStmt_default_instance_;
class DeclareCursorStmt;
class DeclareCursorStmtDefaultTypeInternal;
extern DeclareCursorStmtDefaultTypeInternal _DeclareCursorStmt_default_instance_;
class DefElem;
class DefElemDefaultTypeInternal;
extern DefElemDefaultTypeInternal _DefElem_default_instance_;
class DefineStmt;
class DefineStmtDefaultTypeInternal;
extern DefineStmtDefaultTypeInternal _DefineStmt_default_instance_;
class DeleteStmt;
class DeleteStmtDefaultTypeInternal;
extern DeleteStmtDefaultTypeInternal _DeleteStmt_default_instance_;
class DiscardStmt;
class DiscardStmtDefaultTypeInternal;
extern DiscardStmtDefaultTypeInternal _DiscardStmt_default_instance_;
class DistinctExpr;
class DistinctExprDefaultTypeInternal;
extern DistinctExprDefaultTypeInternal _DistinctExpr_default_instance_;
class DoStmt;
class DoStmtDefaultTypeInternal;
extern DoStmtDefaultTypeInternal _DoStmt_default_instance_;
class DropOwnedStmt;
class DropOwnedStmtDefaultTypeInternal;
extern DropOwnedStmtDefaultTypeInternal _DropOwnedStmt_default_instance_;
class DropRoleStmt;
class DropRoleStmtDefaultTypeInternal;
extern DropRoleStmtDefaultTypeInternal _DropRoleStmt_default_instance_;
class DropStmt;
class DropStmtDefaultTypeInternal;
extern DropStmtDefaultTypeInternal _DropStmt_default_instance_;
class DropSubscriptionStmt;
class DropSubscriptionStmtDefaultTypeInternal;
extern DropSubscriptionStmtDefaultTypeInternal _DropSubscriptionStmt_default_instance_;
class DropTableSpaceStmt;
class DropTableSpaceStmtDefaultTypeInternal;
extern DropTableSpaceStmtDefaultTypeInternal _DropTableSpaceStmt_default_instance_;
class DropUserMappingStmt;
class DropUserMappingStmtDefaultTypeInternal;
extern DropUserMappingStmtDefaultTypeInternal _DropUserMappingStmt_default_instance_;
class DropdbStmt;
class DropdbStmtDefaultTypeInternal;
extern DropdbStmtDefaultTypeInternal _DropdbStmt_default_instance_;
class ExecuteStmt;
class ExecuteStmtDefaultTypeInternal;
extern ExecuteStmtDefaultTypeInternal _ExecuteStmt_default_instance_;
class ExplainStmt;
class ExplainStmtDefaultTypeInternal;
extern ExplainStmtDefaultTypeInternal _ExplainStmt_default_instance_;
class Expr;
class ExprDefaultTypeInternal;
extern ExprDefaultTypeInternal _Expr_default_instance_;
class FetchStmt;
class FetchStmtDefaultTypeInternal;
extern FetchStmtDefaultTypeInternal _FetchStmt_default_instance_;
class FieldSelect;
class FieldSelectDefaultTypeInternal;
extern FieldSelectDefaultTypeInternal _FieldSelect_default_instance_;
class FieldStore;
class FieldStoreDefaultTypeInternal;
extern FieldStoreDefaultTypeInternal _FieldStore_default_instance_;
class Float;
class FloatDefaultTypeInternal;
extern FloatDefaultTypeInternal _Float_default_instance_;
class FromExpr;
class FromExprDefaultTypeInternal;
extern FromExprDefaultTypeInternal _FromExpr_default_instance_;
class FuncCall;
class FuncCallDefaultTypeInternal;
extern FuncCallDefaultTypeInternal _FuncCall_default_instance_;
class FuncExpr;
class FuncExprDefaultTypeInternal;
extern FuncExprDefaultTypeInternal _FuncExpr_default_instance_;
class FunctionParameter;
class FunctionParameterDefaultTypeInternal;
extern FunctionParameterDefaultTypeInternal _FunctionParameter_default_instance_;
class GrantRoleStmt;
class GrantRoleStmtDefaultTypeInternal;
extern GrantRoleStmtDefaultTypeInternal _GrantRoleStmt_default_instance_;
class GrantStmt;
class GrantStmtDefaultTypeInternal;
extern GrantStmtDefaultTypeInternal _GrantStmt_default_instance_;
class GroupingFunc;
class GroupingFuncDefaultTypeInternal;
extern GroupingFuncDefaultTypeInternal _GroupingFunc_default_instance_;
class GroupingSet;
class GroupingSetDefaultTypeInternal;
extern GroupingSetDefaultTypeInternal _GroupingSet_default_instance_;
class ImportForeignSchemaStmt;
class ImportForeignSchemaStmtDefaultTypeInternal;
extern ImportForeignSchemaStmtDefaultTypeInternal _ImportForeignSchemaStmt_default_instance_;
class IndexElem;
class IndexElemDefaultTypeInternal;
extern IndexElemDefaultTypeInternal _IndexElem_default_instance_;
class IndexStmt;
class IndexStmtDefaultTypeInternal;
extern IndexStmtDefaultTypeInternal _IndexStmt_default_instance_;
class InferClause;
class InferClauseDefaultTypeInternal;
extern InferClauseDefaultTypeInternal _InferClause_default_instance_;
class InferenceElem;
class InferenceElemDefaultTypeInternal;
extern InferenceElemDefaultTypeInternal _InferenceElem_default_instance_;
class InlineCodeBlock;
class InlineCodeBlockDefaultTypeInternal;
extern InlineCodeBlockDefaultTypeInternal _InlineCodeBlock_default_instance_;
class InsertStmt;
class InsertStmtDefaultTypeInternal;
extern InsertStmtDefaultTypeInternal _InsertStmt_default_instance_;
class IntList;
class IntListDefaultTypeInternal;
extern IntListDefaultTypeInternal _IntList_default_instance_;
class Integer;
class IntegerDefaultTypeInternal;
extern IntegerDefaultTypeInternal _Integer_default_instance_;
class IntoClause;
class IntoClauseDefaultTypeInternal;
extern IntoClauseDefaultTypeInternal _IntoClause_default_instance_;
class JoinExpr;
class JoinExprDefaultTypeInternal;
extern JoinExprDefaultTypeInternal _JoinExpr_default_instance_;
class List;
class ListDefaultTypeInternal;
extern ListDefaultTypeInternal _List_default_instance_;
class ListenStmt;
class ListenStmtDefaultTypeInternal;
extern ListenStmtDefaultTypeInternal _ListenStmt_default_instance_;
class LoadStmt;
class LoadStmtDefaultTypeInternal;
extern LoadStmtDefaultTypeInternal _LoadStmt_default_instance_;
class LockStmt;
class LockStmtDefaultTypeInternal;
extern LockStmtDefaultTypeInternal _LockStmt_default_instance_;
class LockingClause;
class LockingClauseDefaultTypeInternal;
extern LockingClauseDefaultTypeInternal _LockingClause_default_instance_;
class MinMaxExpr;
class MinMaxExprDefaultTypeInternal;
extern MinMaxExprDefaultTypeInternal _MinMaxExpr_default_instance_;
class MultiAssignRef;
class MultiAssignRefDefaultTypeInternal;
extern MultiAssignRefDefaultTypeInternal _MultiAssignRef_default_instance_;
class NamedArgExpr;
class NamedArgExprDefaultTypeInternal;
extern NamedArgExprDefaultTypeInternal _NamedArgExpr_default_instance_;
class NextValueExpr;
class NextValueExprDefaultTypeInternal;
extern NextValueExprDefaultTypeInternal _NextValueExpr_default_instance_;
class Node;
class NodeDefaultTypeInternal;
extern NodeDefaultTypeInternal _Node_default_instance_;
class NotifyStmt;
class NotifyStmtDefaultTypeInternal;
extern NotifyStmtDefaultTypeInternal _NotifyStmt_default_instance_;
class Null;
class NullDefaultTypeInternal;
extern NullDefaultTypeInternal _Null_default_instance_;
class NullIfExpr;
class NullIfExprDefaultTypeInternal;
extern NullIfExprDefaultTypeInternal _NullIfExpr_default_instance_;
class NullTest;
class NullTestDefaultTypeInternal;
extern NullTestDefaultTypeInternal _NullTest_default_instance_;
class ObjectWithArgs;
class ObjectWithArgsDefaultTypeInternal;
extern ObjectWithArgsDefaultTypeInternal _ObjectWithArgs_default_instance_;
class OidList;
class OidListDefaultTypeInternal;
extern OidListDefaultTypeInternal _OidList_default_instance_;
class OnConflictClause;
class OnConflictClauseDefaultTypeInternal;
extern OnConflictClauseDefaultTypeInternal _OnConflictClause_default_instance_;
class OnConflictExpr;
class OnConflictExprDefaultTypeInternal;
extern OnConflictExprDefaultTypeInternal _OnConflictExpr_default_instance_;
class OpExpr;
class OpExprDefaultTypeInternal;
extern OpExprDefaultTypeInternal _OpExpr_default_instance_;
class Param;
class ParamDefaultTypeInternal;
extern ParamDefaultTypeInternal _Param_default_instance_;
class ParamRef;
class ParamRefDefaultTypeInternal;
extern ParamRefDefaultTypeInternal _ParamRef_default_instance_;
class ParseResult;
class ParseResultDefaultTypeInternal;
extern ParseResultDefaultTypeInternal _ParseResult_default_instance_;
class PartitionBoundSpec;
class PartitionBoundSpecDefaultTypeInternal;
extern PartitionBoundSpecDefaultTypeInternal _PartitionBoundSpec_default_instance_;
class PartitionCmd;
class PartitionCmdDefaultTypeInternal;
extern PartitionCmdDefaultTypeInternal _PartitionCmd_default_instance_;
class PartitionElem;
class PartitionElemDefaultTypeInternal;
extern PartitionElemDefaultTypeInternal _PartitionElem_default_instance_;
class PartitionRangeDatum;
class PartitionRangeDatumDefaultTypeInternal;
extern PartitionRangeDatumDefaultTypeInternal _PartitionRangeDatum_default_instance_;
class PartitionSpec;
class PartitionSpecDefaultTypeInternal;
extern PartitionSpecDefaultTypeInternal _PartitionSpec_default_instance_;
class PrepareStmt;
class PrepareStmtDefaultTypeInternal;
extern PrepareStmtDefaultTypeInternal _PrepareStmt_default_instance_;
class Query;
class QueryDefaultTypeInternal;
extern QueryDefaultTypeInternal _Query_default_instance_;
class RangeFunction;
class RangeFunctionDefaultTypeInternal;
extern RangeFunctionDefaultTypeInternal _RangeFunction_default_instance_;
class RangeSubselect;
class RangeSubselectDefaultTypeInternal;
extern RangeSubselectDefaultTypeInternal _RangeSubselect_default_instance_;
class RangeTableFunc;
class RangeTableFuncDefaultTypeInternal;
extern RangeTableFuncDefaultTypeInternal _RangeTableFunc_default_instance_;
class RangeTableFuncCol;
class RangeTableFuncColDefaultTypeInternal;
extern RangeTableFuncColDefaultTypeInternal _RangeTableFuncCol_default_instance_;
class RangeTableSample;
class RangeTableSampleDefaultTypeInternal;
extern RangeTableSampleDefaultTypeInternal _RangeTableSample_default_instance_;
class RangeTblEntry;
class RangeTblEntryDefaultTypeInternal;
extern RangeTblEntryDefaultTypeInternal _RangeTblEntry_default_instance_;
class RangeTblFunction;
class RangeTblFunctionDefaultTypeInternal;
extern RangeTblFunctionDefaultTypeInternal _RangeTblFunction_default_instance_;
class RangeTblRef;
class RangeTblRefDefaultTypeInternal;
extern RangeTblRefDefaultTypeInternal _RangeTblRef_default_instance_;
class RangeVar;
class RangeVarDefaultTypeInternal;
extern RangeVarDefaultTypeInternal _RangeVar_default_instance_;
class RawStmt;
class RawStmtDefaultTypeInternal;
extern RawStmtDefaultTypeInternal _RawStmt_default_instance_;
class ReassignOwnedStmt;
class ReassignOwnedStmtDefaultTypeInternal;
extern ReassignOwnedStmtDefaultTypeInternal _ReassignOwnedStmt_default_instance_;
class RefreshMatViewStmt;
class RefreshMatViewStmtDefaultTypeInternal;
extern RefreshMatViewStmtDefaultTypeInternal _RefreshMatViewStmt_default_instance_;
class ReindexStmt;
class ReindexStmtDefaultTypeInternal;
extern ReindexStmtDefaultTypeInternal _ReindexStmt_default_instance_;
class RelabelType;
class RelabelTypeDefaultTypeInternal;
extern RelabelTypeDefaultTypeInternal _RelabelType_default_instance_;
class RenameStmt;
class RenameStmtDefaultTypeInternal;
extern RenameStmtDefaultTypeInternal _RenameStmt_default_instance_;
class ReplicaIdentityStmt;
class ReplicaIdentityStmtDefaultTypeInternal;
extern ReplicaIdentityStmtDefaultTypeInternal _ReplicaIdentityStmt_default_instance_;
class ResTarget;
class ResTargetDefaultTypeInternal;
extern ResTargetDefaultTypeInternal _ResTarget_default_instance_;
class RoleSpec;
class RoleSpecDefaultTypeInternal;
extern RoleSpecDefaultTypeInternal _RoleSpec_default_instance_;
class RowCompareExpr;
class RowCompareExprDefaultTypeInternal;
extern RowCompareExprDefaultTypeInternal _RowCompareExpr_default_instance_;
class RowExpr;
class RowExprDefaultTypeInternal;
extern RowExprDefaultTypeInternal _RowExpr_default_instance_;
class RowMarkClause;
class RowMarkClauseDefaultTypeInternal;
extern RowMarkClauseDefaultTypeInternal _RowMarkClause_default_instance_;
class RuleStmt;
class RuleStmtDefaultTypeInternal;
extern RuleStmtDefaultTypeInternal _RuleStmt_default_instance_;
class SQLValueFunction;
class SQLValueFunctionDefaultTypeInternal;
extern SQLValueFunctionDefaultTypeInternal _SQLValueFunction_default_instance_;
class ScalarArrayOpExpr;
class ScalarArrayOpExprDefaultTypeInternal;
extern ScalarArrayOpExprDefaultTypeInternal _ScalarArrayOpExpr_default_instance_;
class ScanResult;
class ScanResultDefaultTypeInternal;
extern ScanResultDefaultTypeInternal _ScanResult_default_instance_;
class ScanToken;
class ScanTokenDefaultTypeInternal;
extern ScanTokenDefaultTypeInternal _ScanToken_default_instance_;
class SecLabelStmt;
class SecLabelStmtDefaultTypeInternal;
extern SecLabelStmtDefaultTypeInternal _SecLabelStmt_default_instance_;
class SelectStmt;
class SelectStmtDefaultTypeInternal;
extern SelectStmtDefaultTypeInternal _SelectStmt_default_instance_;
class SetOperationStmt;
class SetOperationStmtDefaultTypeInternal;
extern SetOperationStmtDefaultTypeInternal _SetOperationStmt_default_instance_;
class SetToDefault;
class SetToDefaultDefaultTypeInternal;
extern SetToDefaultDefaultTypeInternal _SetToDefault_default_instance_;
class SortBy;
class SortByDefaultTypeInternal;
extern SortByDefaultTypeInternal _SortBy_default_instance_;
class SortGroupClause;
class SortGroupClauseDefaultTypeInternal;
extern SortGroupClauseDefaultTypeInternal _SortGroupClause_default_instance_;
class String;
class StringDefaultTypeInternal;
extern StringDefaultTypeInternal _String_default_instance_;
class SubLink;
class SubLinkDefaultTypeInternal;
extern SubLinkDefaultTypeInternal _SubLink_default_instance_;
class SubPlan;
class SubPlanDefaultTypeInternal;
extern SubPlanDefaultTypeInternal _SubPlan_default_instance_;
class SubscriptingRef;
class SubscriptingRefDefaultTypeInternal;
extern SubscriptingRefDefaultTypeInternal _SubscriptingRef_default_instance_;
class TableFunc;
class TableFuncDefaultTypeInternal;
extern TableFuncDefaultTypeInternal _TableFunc_default_instance_;
class TableLikeClause;
class TableLikeClauseDefaultTypeInternal;
extern TableLikeClauseDefaultTypeInternal _TableLikeClause_default_instance_;
class TableSampleClause;
class TableSampleClauseDefaultTypeInternal;
extern TableSampleClauseDefaultTypeInternal _TableSampleClause_default_instance_;
class TargetEntry;
class TargetEntryDefaultTypeInternal;
extern TargetEntryDefaultTypeInternal _TargetEntry_default_instance_;
class TransactionStmt;
class TransactionStmtDefaultTypeInternal;
extern TransactionStmtDefaultTypeInternal _TransactionStmt_default_instance_;
class TriggerTransition;
class TriggerTransitionDefaultTypeInternal;
extern TriggerTransitionDefaultTypeInternal _TriggerTransition_default_instance_;
class TruncateStmt;
class TruncateStmtDefaultTypeInternal;
extern TruncateStmtDefaultTypeInternal _TruncateStmt_default_instance_;
class TypeCast;
class TypeCastDefaultTypeInternal;
extern TypeCastDefaultTypeInternal _TypeCast_default_instance_;
class TypeName;
class TypeNameDefaultTypeInternal;
extern TypeNameDefaultTypeInternal _TypeName_default_instance_;
class UnlistenStmt;
class UnlistenStmtDefaultTypeInternal;
extern UnlistenStmtDefaultTypeInternal _UnlistenStmt_default_instance_;
class UpdateStmt;
class UpdateStmtDefaultTypeInternal;
extern UpdateStmtDefaultTypeInternal _UpdateStmt_default_instance_;
class VacuumRelation;
class VacuumRelationDefaultTypeInternal;
extern VacuumRelationDefaultTypeInternal _VacuumRelation_default_instance_;
class VacuumStmt;
class VacuumStmtDefaultTypeInternal;
extern VacuumStmtDefaultTypeInternal _VacuumStmt_default_instance_;
class Var;
class VarDefaultTypeInternal;
extern VarDefaultTypeInternal _Var_default_instance_;
class VariableSetStmt;
class VariableSetStmtDefaultTypeInternal;
extern VariableSetStmtDefaultTypeInternal _VariableSetStmt_default_instance_;
class VariableShowStmt;
class VariableShowStmtDefaultTypeInternal;
extern VariableShowStmtDefaultTypeInternal _VariableShowStmt_default_instance_;
class ViewStmt;
class ViewStmtDefaultTypeInternal;
extern ViewStmtDefaultTypeInternal _ViewStmt_default_instance_;
class WindowClause;
class WindowClauseDefaultTypeInternal;
extern WindowClauseDefaultTypeInternal _WindowClause_default_instance_;
class WindowDef;
class WindowDefDefaultTypeInternal;
extern WindowDefDefaultTypeInternal _WindowDef_default_instance_;
class WindowFunc;
class WindowFuncDefaultTypeInternal;
extern WindowFuncDefaultTypeInternal _WindowFunc_default_instance_;
class WithCheckOption;
class WithCheckOptionDefaultTypeInternal;
extern WithCheckOptionDefaultTypeInternal _WithCheckOption_default_instance_;
class WithClause;
class WithClauseDefaultTypeInternal;
extern WithClauseDefaultTypeInternal _WithClause_default_instance_;
class XmlExpr;
class XmlExprDefaultTypeInternal;
extern XmlExprDefaultTypeInternal _XmlExpr_default_instance_;
class XmlSerialize;
class XmlSerializeDefaultTypeInternal;
extern XmlSerializeDefaultTypeInternal _XmlSerialize_default_instance_;
}  // namespace pg_query
PROTOBUF_NAMESPACE_OPEN
template<> ::pg_query::A_ArrayExpr* Arena::CreateMaybeMessage<::pg_query::A_ArrayExpr>(Arena*);
template<> ::pg_query::A_Const* Arena::CreateMaybeMessage<::pg_query::A_Const>(Arena*);
template<> ::pg_query::A_Expr* Arena::CreateMaybeMessage<::pg_query::A_Expr>(Arena*);
template<> ::pg_query::A_Indices* Arena::CreateMaybeMessage<::pg_query::A_Indices>(Arena*);
template<> ::pg_query::A_Indirection* Arena::CreateMaybeMessage<::pg_query::A_Indirection>(Arena*);
template<> ::pg_query::A_Star* Arena::CreateMaybeMessage<::pg_query::A_Star>(Arena*);
template<> ::pg_query::AccessPriv* Arena::CreateMaybeMessage<::pg_query::AccessPriv>(Arena*);
template<> ::pg_query::Aggref* Arena::CreateMaybeMessage<::pg_query::Aggref>(Arena*);
template<> ::pg_query::Alias* Arena::CreateMaybeMessage<::pg_query::Alias>(Arena*);
template<> ::pg_query::AlterCollationStmt* Arena::CreateMaybeMessage<::pg_query::AlterCollationStmt>(Arena*);
template<> ::pg_query::AlterDatabaseSetStmt* Arena::CreateMaybeMessage<::pg_query::AlterDatabaseSetStmt>(Arena*);
template<> ::pg_query::AlterDatabaseStmt* Arena::CreateMaybeMessage<::pg_query::AlterDatabaseStmt>(Arena*);
template<> ::pg_query::AlterDefaultPrivilegesStmt* Arena::CreateMaybeMessage<::pg_query::AlterDefaultPrivilegesStmt>(Arena*);
template<> ::pg_query::AlterDomainStmt* Arena::CreateMaybeMessage<::pg_query::AlterDomainStmt>(Arena*);
template<> ::pg_query::AlterEnumStmt* Arena::CreateMaybeMessage<::pg_query::AlterEnumStmt>(Arena*);
template<> ::pg_query::AlterEventTrigStmt* Arena::CreateMaybeMessage<::pg_query::AlterEventTrigStmt>(Arena*);
template<> ::pg_query::AlterExtensionContentsStmt* Arena::CreateMaybeMessage<::pg_query::AlterExtensionContentsStmt>(Arena*);
template<> ::pg_query::AlterExtensionStmt* Arena::CreateMaybeMessage<::pg_query::AlterExtensionStmt>(Arena*);
template<> ::pg_query::AlterFdwStmt* Arena::CreateMaybeMessage<::pg_query::AlterFdwStmt>(Arena*);
template<> ::pg_query::AlterForeignServerStmt* Arena::CreateMaybeMessage<::pg_query::AlterForeignServerStmt>(Arena*);
template<> ::pg_query::AlterFunctionStmt* Arena::CreateMaybeMessage<::pg_query::AlterFunctionStmt>(Arena*);
template<> ::pg_query::AlterObjectDependsStmt* Arena::CreateMaybeMessage<::pg_query::AlterObjectDependsStmt>(Arena*);
template<> ::pg_query::AlterObjectSchemaStmt* Arena::CreateMaybeMessage<::pg_query::AlterObjectSchemaStmt>(Arena*);
template<> ::pg_query::AlterOpFamilyStmt* Arena::CreateMaybeMessage<::pg_query::AlterOpFamilyStmt>(Arena*);
template<> ::pg_query::AlterOperatorStmt* Arena::CreateMaybeMessage<::pg_query::AlterOperatorStmt>(Arena*);
template<> ::pg_query::AlterOwnerStmt* Arena::CreateMaybeMessage<::pg_query::AlterOwnerStmt>(Arena*);
template<> ::pg_query::AlterPolicyStmt* Arena::CreateMaybeMessage<::pg_query::AlterPolicyStmt>(Arena*);
template<> ::pg_query::AlterPublicationStmt* Arena::CreateMaybeMessage<::pg_query::AlterPublicationStmt>(Arena*);
template<> ::pg_query::AlterRoleSetStmt* Arena::CreateMaybeMessage<::pg_query::AlterRoleSetStmt>(Arena*);
template<> ::pg_query::AlterRoleStmt* Arena::CreateMaybeMessage<::pg_query::AlterRoleStmt>(Arena*);
template<> ::pg_query::AlterSeqStmt* Arena::CreateMaybeMessage<::pg_query::AlterSeqStmt>(Arena*);
template<> ::pg_query::AlterStatsStmt* Arena::CreateMaybeMessage<::pg_query::AlterStatsStmt>(Arena*);
template<> ::pg_query::AlterSubscriptionStmt* Arena::CreateMaybeMessage<::pg_query::AlterSubscriptionStmt>(Arena*);
template<> ::pg_query::AlterSystemStmt* Arena::CreateMaybeMessage<::pg_query::AlterSystemStmt>(Arena*);
template<> ::pg_query::AlterTSConfigurationStmt* Arena::CreateMaybeMessage<::pg_query::AlterTSConfigurationStmt>(Arena*);
template<> ::pg_query::AlterTSDictionaryStmt* Arena::CreateMaybeMessage<::pg_query::AlterTSDictionaryStmt>(Arena*);
template<> ::pg_query::AlterTableCmd* Arena::CreateMaybeMessage<::pg_query::AlterTableCmd>(Arena*);
template<> ::pg_query::AlterTableMoveAllStmt* Arena::CreateMaybeMessage<::pg_query::AlterTableMoveAllStmt>(Arena*);
template<> ::pg_query::AlterTableSpaceOptionsStmt* Arena::CreateMaybeMessage<::pg_query::AlterTableSpaceOptionsStmt>(Arena*);
template<> ::pg_query::AlterTableStmt* Arena::CreateMaybeMessage<::pg_query::AlterTableStmt>(Arena*);
template<> ::pg_query::AlterTypeStmt* Arena::CreateMaybeMessage<::pg_query::AlterTypeStmt>(Arena*);
template<> ::pg_query::AlterUserMappingStmt* Arena::CreateMaybeMessage<::pg_query::AlterUserMappingStmt>(Arena*);
template<> ::pg_query::AlternativeSubPlan* Arena::CreateMaybeMessage<::pg_query::AlternativeSubPlan>(Arena*);
template<> ::pg_query::ArrayCoerceExpr* Arena::CreateMaybeMessage<::pg_query::ArrayCoerceExpr>(Arena*);
template<> ::pg_query::ArrayExpr* Arena::CreateMaybeMessage<::pg_query::ArrayExpr>(Arena*);
template<> ::pg_query::BitString* Arena::CreateMaybeMessage<::pg_query::BitString>(Arena*);
template<> ::pg_query::Bitmapset* Arena::CreateMaybeMessage<::pg_query::Bitmapset>(Arena*);
template<> ::pg_query::BoolExpr* Arena::CreateMaybeMessage<::pg_query::BoolExpr>(Arena*);
template<> ::pg_query::BooleanTest* Arena::CreateMaybeMessage<::pg_query::BooleanTest>(Arena*);
template<> ::pg_query::CallContext* Arena::CreateMaybeMessage<::pg_query::CallContext>(Arena*);
template<> ::pg_query::CallStmt* Arena::CreateMaybeMessage<::pg_query::CallStmt>(Arena*);
template<> ::pg_query::CaseExpr* Arena::CreateMaybeMessage<::pg_query::CaseExpr>(Arena*);
template<> ::pg_query::CaseTestExpr* Arena::CreateMaybeMessage<::pg_query::CaseTestExpr>(Arena*);
template<> ::pg_query::CaseWhen* Arena::CreateMaybeMessage<::pg_query::CaseWhen>(Arena*);
template<> ::pg_query::CheckPointStmt* Arena::CreateMaybeMessage<::pg_query::CheckPointStmt>(Arena*);
template<> ::pg_query::ClosePortalStmt* Arena::CreateMaybeMessage<::pg_query::ClosePortalStmt>(Arena*);
template<> ::pg_query::ClusterStmt* Arena::CreateMaybeMessage<::pg_query::ClusterStmt>(Arena*);
template<> ::pg_query::CoalesceExpr* Arena::CreateMaybeMessage<::pg_query::CoalesceExpr>(Arena*);
template<> ::pg_query::CoerceToDomain* Arena::CreateMaybeMessage<::pg_query::CoerceToDomain>(Arena*);
template<> ::pg_query::CoerceToDomainValue* Arena::CreateMaybeMessage<::pg_query::CoerceToDomainValue>(Arena*);
template<> ::pg_query::CoerceViaIO* Arena::CreateMaybeMessage<::pg_query::CoerceViaIO>(Arena*);
template<> ::pg_query::CollateClause* Arena::CreateMaybeMessage<::pg_query::CollateClause>(Arena*);
template<> ::pg_query::CollateExpr* Arena::CreateMaybeMessage<::pg_query::CollateExpr>(Arena*);
template<> ::pg_query::ColumnDef* Arena::CreateMaybeMessage<::pg_query::ColumnDef>(Arena*);
template<> ::pg_query::ColumnRef* Arena::CreateMaybeMessage<::pg_query::ColumnRef>(Arena*);
template<> ::pg_query::CommentStmt* Arena::CreateMaybeMessage<::pg_query::CommentStmt>(Arena*);
template<> ::pg_query::CommonTableExpr* Arena::CreateMaybeMessage<::pg_query::CommonTableExpr>(Arena*);
template<> ::pg_query::CompositeTypeStmt* Arena::CreateMaybeMessage<::pg_query::CompositeTypeStmt>(Arena*);
template<> ::pg_query::Constraint* Arena::CreateMaybeMessage<::pg_query::Constraint>(Arena*);
template<> ::pg_query::ConstraintsSetStmt* Arena::CreateMaybeMessage<::pg_query::ConstraintsSetStmt>(Arena*);
template<> ::pg_query::ConvertRowtypeExpr* Arena::CreateMaybeMessage<::pg_query::ConvertRowtypeExpr>(Arena*);
template<> ::pg_query::CopyStmt* Arena::CreateMaybeMessage<::pg_query::CopyStmt>(Arena*);
template<> ::pg_query::CreateAmStmt* Arena::CreateMaybeMessage<::pg_query::CreateAmStmt>(Arena*);
template<> ::pg_query::CreateCastStmt* Arena::CreateMaybeMessage<::pg_query::CreateCastStmt>(Arena*);
template<> ::pg_query::CreateConversionStmt* Arena::CreateMaybeMessage<::pg_query::CreateConversionStmt>(Arena*);
template<> ::pg_query::CreateDomainStmt* Arena::CreateMaybeMessage<::pg_query::CreateDomainStmt>(Arena*);
template<> ::pg_query::CreateEnumStmt* Arena::CreateMaybeMessage<::pg_query::CreateEnumStmt>(Arena*);
template<> ::pg_query::CreateEventTrigStmt* Arena::CreateMaybeMessage<::pg_query::CreateEventTrigStmt>(Arena*);
template<> ::pg_query::CreateExtensionStmt* Arena::CreateMaybeMessage<::pg_query::CreateExtensionStmt>(Arena*);
template<> ::pg_query::CreateFdwStmt* Arena::CreateMaybeMessage<::pg_query::CreateFdwStmt>(Arena*);
template<> ::pg_query::CreateForeignServerStmt* Arena::CreateMaybeMessage<::pg_query::CreateForeignServerStmt>(Arena*);
template<> ::pg_query::CreateForeignTableStmt* Arena::CreateMaybeMessage<::pg_query::CreateForeignTableStmt>(Arena*);
template<> ::pg_query::CreateFunctionStmt* Arena::CreateMaybeMessage<::pg_query::CreateFunctionStmt>(Arena*);
template<> ::pg_query::CreateOpClassItem* Arena::CreateMaybeMessage<::pg_query::CreateOpClassItem>(Arena*);
template<> ::pg_query::CreateOpClassStmt* Arena::CreateMaybeMessage<::pg_query::CreateOpClassStmt>(Arena*);
template<> ::pg_query::CreateOpFamilyStmt* Arena::CreateMaybeMessage<::pg_query::CreateOpFamilyStmt>(Arena*);
template<> ::pg_query::CreatePLangStmt* Arena::CreateMaybeMessage<::pg_query::CreatePLangStmt>(Arena*);
template<> ::pg_query::CreatePolicyStmt* Arena::CreateMaybeMessage<::pg_query::CreatePolicyStmt>(Arena*);
template<> ::pg_query::CreatePublicationStmt* Arena::CreateMaybeMessage<::pg_query::CreatePublicationStmt>(Arena*);
template<> ::pg_query::CreateRangeStmt* Arena::CreateMaybeMessage<::pg_query::CreateRangeStmt>(Arena*);
template<> ::pg_query::CreateRoleStmt* Arena::CreateMaybeMessage<::pg_query::CreateRoleStmt>(Arena*);
template<> ::pg_query::CreateSchemaStmt* Arena::CreateMaybeMessage<::pg_query::CreateSchemaStmt>(Arena*);
template<> ::pg_query::CreateSeqStmt* Arena::CreateMaybeMessage<::pg_query::CreateSeqStmt>(Arena*);
template<> ::pg_query::CreateStatsStmt* Arena::CreateMaybeMessage<::pg_query::CreateStatsStmt>(Arena*);
template<> ::pg_query::CreateStmt* Arena::CreateMaybeMessage<::pg_query::CreateStmt>(Arena*);
template<> ::pg_query::CreateSubscriptionStmt* Arena::CreateMaybeMessage<::pg_query::CreateSubscriptionStmt>(Arena*);
template<> ::pg_query::CreateTableAsStmt* Arena::CreateMaybeMessage<::pg_query::CreateTableAsStmt>(Arena*);
template<> ::pg_query::CreateTableSpaceStmt* Arena::CreateMaybeMessage<::pg_query::CreateTableSpaceStmt>(Arena*);
template<> ::pg_query::CreateTransformStmt* Arena::CreateMaybeMessage<::pg_query::CreateTransformStmt>(Arena*);
template<> ::pg_query::CreateTrigStmt* Arena::CreateMaybeMessage<::pg_query::CreateTrigStmt>(Arena*);
template<> ::pg_query::CreateUserMappingStmt* Arena::CreateMaybeMessage<::pg_query::CreateUserMappingStmt>(Arena*);
template<> ::pg_query::CreatedbStmt* Arena::CreateMaybeMessage<::pg_query::CreatedbStmt>(Arena*);
template<> ::pg_query::CurrentOfExpr* Arena::CreateMaybeMessage<::pg_query::CurrentOfExpr>(Arena*);
template<> ::pg_query::DeallocateStmt* Arena::CreateMaybeMessage<::pg_query::DeallocateStmt>(Arena*);
template<> ::pg_query::DeclareCursorStmt* Arena::CreateMaybeMessage<::pg_query::DeclareCursorStmt>(Arena*);
template<> ::pg_query::DefElem* Arena::CreateMaybeMessage<::pg_query::DefElem>(Arena*);
template<> ::pg_query::DefineStmt* Arena::CreateMaybeMessage<::pg_query::DefineStmt>(Arena*);
template<> ::pg_query::DeleteStmt* Arena::CreateMaybeMessage<::pg_query::DeleteStmt>(Arena*);
template<> ::pg_query::DiscardStmt* Arena::CreateMaybeMessage<::pg_query::DiscardStmt>(Arena*);
template<> ::pg_query::DistinctExpr* Arena::CreateMaybeMessage<::pg_query::DistinctExpr>(Arena*);
template<> ::pg_query::DoStmt* Arena::CreateMaybeMessage<::pg_query::DoStmt>(Arena*);
template<> ::pg_query::DropOwnedStmt* Arena::CreateMaybeMessage<::pg_query::DropOwnedStmt>(Arena*);
template<> ::pg_query::DropRoleStmt* Arena::CreateMaybeMessage<::pg_query::DropRoleStmt>(Arena*);
template<> ::pg_query::DropStmt* Arena::CreateMaybeMessage<::pg_query::DropStmt>(Arena*);
template<> ::pg_query::DropSubscriptionStmt* Arena::CreateMaybeMessage<::pg_query::DropSubscriptionStmt>(Arena*);
template<> ::pg_query::DropTableSpaceStmt* Arena::CreateMaybeMessage<::pg_query::DropTableSpaceStmt>(Arena*);
template<> ::pg_query::DropUserMappingStmt* Arena::CreateMaybeMessage<::pg_query::DropUserMappingStmt>(Arena*);
template<> ::pg_query::DropdbStmt* Arena::CreateMaybeMessage<::pg_query::DropdbStmt>(Arena*);
template<> ::pg_query::ExecuteStmt* Arena::CreateMaybeMessage<::pg_query::ExecuteStmt>(Arena*);
template<> ::pg_query::ExplainStmt* Arena::CreateMaybeMessage<::pg_query::ExplainStmt>(Arena*);
template<> ::pg_query::Expr* Arena::CreateMaybeMessage<::pg_query::Expr>(Arena*);
template<> ::pg_query::FetchStmt* Arena::CreateMaybeMessage<::pg_query::FetchStmt>(Arena*);
template<> ::pg_query::FieldSelect* Arena::CreateMaybeMessage<::pg_query::FieldSelect>(Arena*);
template<> ::pg_query::FieldStore* Arena::CreateMaybeMessage<::pg_query::FieldStore>(Arena*);
template<> ::pg_query::Float* Arena::CreateMaybeMessage<::pg_query::Float>(Arena*);
template<> ::pg_query::FromExpr* Arena::CreateMaybeMessage<::pg_query::FromExpr>(Arena*);
template<> ::pg_query::FuncCall* Arena::CreateMaybeMessage<::pg_query::FuncCall>(Arena*);
template<> ::pg_query::FuncExpr* Arena::CreateMaybeMessage<::pg_query::FuncExpr>(Arena*);
template<> ::pg_query::FunctionParameter* Arena::CreateMaybeMessage<::pg_query::FunctionParameter>(Arena*);
template<> ::pg_query::GrantRoleStmt* Arena::CreateMaybeMessage<::pg_query::GrantRoleStmt>(Arena*);
template<> ::pg_query::GrantStmt* Arena::CreateMaybeMessage<::pg_query::GrantStmt>(Arena*);
template<> ::pg_query::GroupingFunc* Arena::CreateMaybeMessage<::pg_query::GroupingFunc>(Arena*);
template<> ::pg_query::GroupingSet* Arena::CreateMaybeMessage<::pg_query::GroupingSet>(Arena*);
template<> ::pg_query::ImportForeignSchemaStmt* Arena::CreateMaybeMessage<::pg_query::ImportForeignSchemaStmt>(Arena*);
template<> ::pg_query::IndexElem* Arena::CreateMaybeMessage<::pg_query::IndexElem>(Arena*);
template<> ::pg_query::IndexStmt* Arena::CreateMaybeMessage<::pg_query::IndexStmt>(Arena*);
template<> ::pg_query::InferClause* Arena::CreateMaybeMessage<::pg_query::InferClause>(Arena*);
template<> ::pg_query::InferenceElem* Arena::CreateMaybeMessage<::pg_query::InferenceElem>(Arena*);
template<> ::pg_query::InlineCodeBlock* Arena::CreateMaybeMessage<::pg_query::InlineCodeBlock>(Arena*);
template<> ::pg_query::InsertStmt* Arena::CreateMaybeMessage<::pg_query::InsertStmt>(Arena*);
template<> ::pg_query::IntList* Arena::CreateMaybeMessage<::pg_query::IntList>(Arena*);
template<> ::pg_query::Integer* Arena::CreateMaybeMessage<::pg_query::Integer>(Arena*);
template<> ::pg_query::IntoClause* Arena::CreateMaybeMessage<::pg_query::IntoClause>(Arena*);
template<> ::pg_query::JoinExpr* Arena::CreateMaybeMessage<::pg_query::JoinExpr>(Arena*);
template<> ::pg_query::List* Arena::CreateMaybeMessage<::pg_query::List>(Arena*);
template<> ::pg_query::ListenStmt* Arena::CreateMaybeMessage<::pg_query::ListenStmt>(Arena*);
template<> ::pg_query::LoadStmt* Arena::CreateMaybeMessage<::pg_query::LoadStmt>(Arena*);
template<> ::pg_query::LockStmt* Arena::CreateMaybeMessage<::pg_query::LockStmt>(Arena*);
template<> ::pg_query::LockingClause* Arena::CreateMaybeMessage<::pg_query::LockingClause>(Arena*);
template<> ::pg_query::MinMaxExpr* Arena::CreateMaybeMessage<::pg_query::MinMaxExpr>(Arena*);
template<> ::pg_query::MultiAssignRef* Arena::CreateMaybeMessage<::pg_query::MultiAssignRef>(Arena*);
template<> ::pg_query::NamedArgExpr* Arena::CreateMaybeMessage<::pg_query::NamedArgExpr>(Arena*);
template<> ::pg_query::NextValueExpr* Arena::CreateMaybeMessage<::pg_query::NextValueExpr>(Arena*);
template<> ::pg_query::Node* Arena::CreateMaybeMessage<::pg_query::Node>(Arena*);
template<> ::pg_query::NotifyStmt* Arena::CreateMaybeMessage<::pg_query::NotifyStmt>(Arena*);
template<> ::pg_query::Null* Arena::CreateMaybeMessage<::pg_query::Null>(Arena*);
template<> ::pg_query::NullIfExpr* Arena::CreateMaybeMessage<::pg_query::NullIfExpr>(Arena*);
template<> ::pg_query::NullTest* Arena::CreateMaybeMessage<::pg_query::NullTest>(Arena*);
template<> ::pg_query::ObjectWithArgs* Arena::CreateMaybeMessage<::pg_query::ObjectWithArgs>(Arena*);
template<> ::pg_query::OidList* Arena::CreateMaybeMessage<::pg_query::OidList>(Arena*);
template<> ::pg_query::OnConflictClause* Arena::CreateMaybeMessage<::pg_query::OnConflictClause>(Arena*);
template<> ::pg_query::OnConflictExpr* Arena::CreateMaybeMessage<::pg_query::OnConflictExpr>(Arena*);
template<> ::pg_query::OpExpr* Arena::CreateMaybeMessage<::pg_query::OpExpr>(Arena*);
template<> ::pg_query::Param* Arena::CreateMaybeMessage<::pg_query::Param>(Arena*);
template<> ::pg_query::ParamRef* Arena::CreateMaybeMessage<::pg_query::ParamRef>(Arena*);
template<> ::pg_query::ParseResult* Arena::CreateMaybeMessage<::pg_query::ParseResult>(Arena*);
template<> ::pg_query::PartitionBoundSpec* Arena::CreateMaybeMessage<::pg_query::PartitionBoundSpec>(Arena*);
template<> ::pg_query::PartitionCmd* Arena::CreateMaybeMessage<::pg_query::PartitionCmd>(Arena*);
template<> ::pg_query::PartitionElem* Arena::CreateMaybeMessage<::pg_query::PartitionElem>(Arena*);
template<> ::pg_query::PartitionRangeDatum* Arena::CreateMaybeMessage<::pg_query::PartitionRangeDatum>(Arena*);
template<> ::pg_query::PartitionSpec* Arena::CreateMaybeMessage<::pg_query::PartitionSpec>(Arena*);
template<> ::pg_query::PrepareStmt* Arena::CreateMaybeMessage<::pg_query::PrepareStmt>(Arena*);
template<> ::pg_query::Query* Arena::CreateMaybeMessage<::pg_query::Query>(Arena*);
template<> ::pg_query::RangeFunction* Arena::CreateMaybeMessage<::pg_query::RangeFunction>(Arena*);
template<> ::pg_query::RangeSubselect* Arena::CreateMaybeMessage<::pg_query::RangeSubselect>(Arena*);
template<> ::pg_query::RangeTableFunc* Arena::CreateMaybeMessage<::pg_query::RangeTableFunc>(Arena*);
template<> ::pg_query::RangeTableFuncCol* Arena::CreateMaybeMessage<::pg_query::RangeTableFuncCol>(Arena*);
template<> ::pg_query::RangeTableSample* Arena::CreateMaybeMessage<::pg_query::RangeTableSample>(Arena*);
template<> ::pg_query::RangeTblEntry* Arena::CreateMaybeMessage<::pg_query::RangeTblEntry>(Arena*);
template<> ::pg_query::RangeTblFunction* Arena::CreateMaybeMessage<::pg_query::RangeTblFunction>(Arena*);
template<> ::pg_query::RangeTblRef* Arena::CreateMaybeMessage<::pg_query::RangeTblRef>(Arena*);
template<> ::pg_query::RangeVar* Arena::CreateMaybeMessage<::pg_query::RangeVar>(Arena*);
template<> ::pg_query::RawStmt* Arena::CreateMaybeMessage<::pg_query::RawStmt>(Arena*);
template<> ::pg_query::ReassignOwnedStmt* Arena::CreateMaybeMessage<::pg_query::ReassignOwnedStmt>(Arena*);
template<> ::pg_query::RefreshMatViewStmt* Arena::CreateMaybeMessage<::pg_query::RefreshMatViewStmt>(Arena*);
template<> ::pg_query::ReindexStmt* Arena::CreateMaybeMessage<::pg_query::ReindexStmt>(Arena*);
template<> ::pg_query::RelabelType* Arena::CreateMaybeMessage<::pg_query::RelabelType>(Arena*);
template<> ::pg_query::RenameStmt* Arena::CreateMaybeMessage<::pg_query::RenameStmt>(Arena*);
template<> ::pg_query::ReplicaIdentityStmt* Arena::CreateMaybeMessage<::pg_query::ReplicaIdentityStmt>(Arena*);
template<> ::pg_query::ResTarget* Arena::CreateMaybeMessage<::pg_query::ResTarget>(Arena*);
template<> ::pg_query::RoleSpec* Arena::CreateMaybeMessage<::pg_query::RoleSpec>(Arena*);
template<> ::pg_query::RowCompareExpr* Arena::CreateMaybeMessage<::pg_query::RowCompareExpr>(Arena*);
template<> ::pg_query::RowExpr* Arena::CreateMaybeMessage<::pg_query::RowExpr>(Arena*);
template<> ::pg_query::RowMarkClause* Arena::CreateMaybeMessage<::pg_query::RowMarkClause>(Arena*);
template<> ::pg_query::RuleStmt* Arena::CreateMaybeMessage<::pg_query::RuleStmt>(Arena*);
template<> ::pg_query::SQLValueFunction* Arena::CreateMaybeMessage<::pg_query::SQLValueFunction>(Arena*);
template<> ::pg_query::ScalarArrayOpExpr* Arena::CreateMaybeMessage<::pg_query::ScalarArrayOpExpr>(Arena*);
template<> ::pg_query::ScanResult* Arena::CreateMaybeMessage<::pg_query::ScanResult>(Arena*);
template<> ::pg_query::ScanToken* Arena::CreateMaybeMessage<::pg_query::ScanToken>(Arena*);
template<> ::pg_query::SecLabelStmt* Arena::CreateMaybeMessage<::pg_query::SecLabelStmt>(Arena*);
template<> ::pg_query::SelectStmt* Arena::CreateMaybeMessage<::pg_query::SelectStmt>(Arena*);
template<> ::pg_query::SetOperationStmt* Arena::CreateMaybeMessage<::pg_query::SetOperationStmt>(Arena*);
template<> ::pg_query::SetToDefault* Arena::CreateMaybeMessage<::pg_query::SetToDefault>(Arena*);
template<> ::pg_query::SortBy* Arena::CreateMaybeMessage<::pg_query::SortBy>(Arena*);
template<> ::pg_query::SortGroupClause* Arena::CreateMaybeMessage<::pg_query::SortGroupClause>(Arena*);
template<> ::pg_query::String* Arena::CreateMaybeMessage<::pg_query::String>(Arena*);
template<> ::pg_query::SubLink* Arena::CreateMaybeMessage<::pg_query::SubLink>(Arena*);
template<> ::pg_query::SubPlan* Arena::CreateMaybeMessage<::pg_query::SubPlan>(Arena*);
template<> ::pg_query::SubscriptingRef* Arena::CreateMaybeMessage<::pg_query::SubscriptingRef>(Arena*);
template<> ::pg_query::TableFunc* Arena::CreateMaybeMessage<::pg_query::TableFunc>(Arena*);
template<> ::pg_query::TableLikeClause* Arena::CreateMaybeMessage<::pg_query::TableLikeClause>(Arena*);
template<> ::pg_query::TableSampleClause* Arena::CreateMaybeMessage<::pg_query::TableSampleClause>(Arena*);
template<> ::pg_query::TargetEntry* Arena::CreateMaybeMessage<::pg_query::TargetEntry>(Arena*);
template<> ::pg_query::TransactionStmt* Arena::CreateMaybeMessage<::pg_query::TransactionStmt>(Arena*);
template<> ::pg_query::TriggerTransition* Arena::CreateMaybeMessage<::pg_query::TriggerTransition>(Arena*);
template<> ::pg_query::TruncateStmt* Arena::CreateMaybeMessage<::pg_query::TruncateStmt>(Arena*);
template<> ::pg_query::TypeCast* Arena::CreateMaybeMessage<::pg_query::TypeCast>(Arena*);
template<> ::pg_query::TypeName* Arena::CreateMaybeMessage<::pg_query::TypeName>(Arena*);
template<> ::pg_query::UnlistenStmt* Arena::CreateMaybeMessage<::pg_query::UnlistenStmt>(Arena*);
template<> ::pg_query::UpdateStmt* Arena::CreateMaybeMessage<::pg_query::UpdateStmt>(Arena*);
template<> ::pg_query::VacuumRelation* Arena::CreateMaybeMessage<::pg_query::VacuumRelation>(Arena*);
template<> ::pg_query::VacuumStmt* Arena::CreateMaybeMessage<::pg_query::VacuumStmt>(Arena*);
template<> ::pg_query::Var* Arena::CreateMaybeMessage<::pg_query::Var>(Arena*);
template<> ::pg_query::VariableSetStmt* Arena::CreateMaybeMessage<::pg_query::VariableSetStmt>(Arena*);
template<> ::pg_query::VariableShowStmt* Arena::CreateMaybeMessage<::pg_query::VariableShowStmt>(Arena*);
template<> ::pg_query::ViewStmt* Arena::CreateMaybeMessage<::pg_query::ViewStmt>(Arena*);
template<> ::pg_query::WindowClause* Arena::CreateMaybeMessage<::pg_query::WindowClause>(Arena*);
template<> ::pg_query::WindowDef* Arena::CreateMaybeMessage<::pg_query::WindowDef>(Arena*);
template<> ::pg_query::WindowFunc* Arena::CreateMaybeMessage<::pg_query::WindowFunc>(Arena*);
template<> ::pg_query::WithCheckOption* Arena::CreateMaybeMessage<::pg_query::WithCheckOption>(Arena*);
template<> ::pg_query::WithClause* Arena::CreateMaybeMessage<::pg_query::WithClause>(Arena*);
template<> ::pg_query::XmlExpr* Arena::CreateMaybeMessage<::pg_query::XmlExpr>(Arena*);
template<> ::pg_query::XmlSerialize* Arena::CreateMaybeMessage<::pg_query::XmlSerialize>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace pg_query {

enum OverridingKind : int {
  OVERRIDING_KIND_UNDEFINED = 0,
  OVERRIDING_NOT_SET = 1,
  OVERRIDING_USER_VALUE = 2,
  OVERRIDING_SYSTEM_VALUE = 3,
  OverridingKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  OverridingKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool OverridingKind_IsValid(int value);
constexpr OverridingKind OverridingKind_MIN = OVERRIDING_KIND_UNDEFINED;
constexpr OverridingKind OverridingKind_MAX = OVERRIDING_SYSTEM_VALUE;
constexpr int OverridingKind_ARRAYSIZE = OverridingKind_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OverridingKind_descriptor();
template<typename T>
inline const std::string& OverridingKind_Name(T enum_t_value) {
  static_assert(::std::is_same<T, OverridingKind>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function OverridingKind_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    OverridingKind_descriptor(), enum_t_value);
}
inline bool OverridingKind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OverridingKind* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<OverridingKind>(
    OverridingKind_descriptor(), name, value);
}
enum QuerySource : int {
  QUERY_SOURCE_UNDEFINED = 0,
  QSRC_ORIGINAL = 1,
  QSRC_PARSER = 2,
  QSRC_INSTEAD_RULE = 3,
  QSRC_QUAL_INSTEAD_RULE = 4,
  QSRC_NON_INSTEAD_RULE = 5,
  QuerySource_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  QuerySource_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool QuerySource_IsValid(int value);
constexpr QuerySource QuerySource_MIN = QUERY_SOURCE_UNDEFINED;
constexpr QuerySource QuerySource_MAX = QSRC_NON_INSTEAD_RULE;
constexpr int QuerySource_ARRAYSIZE = QuerySource_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* QuerySource_descriptor();
template<typename T>
inline const std::string& QuerySource_Name(T enum_t_value) {
  static_assert(::std::is_same<T, QuerySource>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function QuerySource_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    QuerySource_descriptor(), enum_t_value);
}
inline bool QuerySource_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, QuerySource* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<QuerySource>(
    QuerySource_descriptor(), name, value);
}
enum SortByDir : int {
  SORT_BY_DIR_UNDEFINED = 0,
  SORTBY_DEFAULT = 1,
  SORTBY_ASC = 2,
  SORTBY_DESC = 3,
  SORTBY_USING = 4,
  SortByDir_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  SortByDir_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool SortByDir_IsValid(int value);
constexpr SortByDir SortByDir_MIN = SORT_BY_DIR_UNDEFINED;
constexpr SortByDir SortByDir_MAX = SORTBY_USING;
constexpr int SortByDir_ARRAYSIZE = SortByDir_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SortByDir_descriptor();
template<typename T>
inline const std::string& SortByDir_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SortByDir>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SortByDir_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SortByDir_descriptor(), enum_t_value);
}
inline bool SortByDir_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SortByDir* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SortByDir>(
    SortByDir_descriptor(), name, value);
}
enum SortByNulls : int {
  SORT_BY_NULLS_UNDEFINED = 0,
  SORTBY_NULLS_DEFAULT = 1,
  SORTBY_NULLS_FIRST = 2,
  SORTBY_NULLS_LAST = 3,
  SortByNulls_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  SortByNulls_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool SortByNulls_IsValid(int value);
constexpr SortByNulls SortByNulls_MIN = SORT_BY_NULLS_UNDEFINED;
constexpr SortByNulls SortByNulls_MAX = SORTBY_NULLS_LAST;
constexpr int SortByNulls_ARRAYSIZE = SortByNulls_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SortByNulls_descriptor();
template<typename T>
inline const std::string& SortByNulls_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SortByNulls>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SortByNulls_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SortByNulls_descriptor(), enum_t_value);
}
inline bool SortByNulls_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SortByNulls* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SortByNulls>(
    SortByNulls_descriptor(), name, value);
}
enum A_Expr_Kind : int {
  A_EXPR_KIND_UNDEFINED = 0,
  AEXPR_OP = 1,
  AEXPR_OP_ANY = 2,
  AEXPR_OP_ALL = 3,
  AEXPR_DISTINCT = 4,
  AEXPR_NOT_DISTINCT = 5,
  AEXPR_NULLIF = 6,
  AEXPR_OF = 7,
  AEXPR_IN = 8,
  AEXPR_LIKE = 9,
  AEXPR_ILIKE = 10,
  AEXPR_SIMILAR = 11,
  AEXPR_BETWEEN = 12,
  AEXPR_NOT_BETWEEN = 13,
  AEXPR_BETWEEN_SYM = 14,
  AEXPR_NOT_BETWEEN_SYM = 15,
  AEXPR_PAREN = 16,
  A_Expr_Kind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  A_Expr_Kind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool A_Expr_Kind_IsValid(int value);
constexpr A_Expr_Kind A_Expr_Kind_MIN = A_EXPR_KIND_UNDEFINED;
constexpr A_Expr_Kind A_Expr_Kind_MAX = AEXPR_PAREN;
constexpr int A_Expr_Kind_ARRAYSIZE = A_Expr_Kind_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* A_Expr_Kind_descriptor();
template<typename T>
inline const std::string& A_Expr_Kind_Name(T enum_t_value) {
  static_assert(::std::is_same<T, A_Expr_Kind>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function A_Expr_Kind_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    A_Expr_Kind_descriptor(), enum_t_value);
}
inline bool A_Expr_Kind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, A_Expr_Kind* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<A_Expr_Kind>(
    A_Expr_Kind_descriptor(), name, value);
}
enum RoleSpecType : int {
  ROLE_SPEC_TYPE_UNDEFINED = 0,
  ROLESPEC_CSTRING = 1,
  ROLESPEC_CURRENT_USER = 2,
  ROLESPEC_SESSION_USER = 3,
  ROLESPEC_PUBLIC = 4,
  RoleSpecType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  RoleSpecType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool RoleSpecType_IsValid(int value);
constexpr RoleSpecType RoleSpecType_MIN = ROLE_SPEC_TYPE_UNDEFINED;
constexpr RoleSpecType RoleSpecType_MAX = ROLESPEC_PUBLIC;
constexpr int RoleSpecType_ARRAYSIZE = RoleSpecType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RoleSpecType_descriptor();
template<typename T>
inline const std::string& RoleSpecType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, RoleSpecType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function RoleSpecType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    RoleSpecType_descriptor(), enum_t_value);
}
inline bool RoleSpecType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RoleSpecType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RoleSpecType>(
    RoleSpecType_descriptor(), name, value);
}
enum TableLikeOption : int {
  TABLE_LIKE_OPTION_UNDEFINED = 0,
  CREATE_TABLE_LIKE_COMMENTS = 1,
  CREATE_TABLE_LIKE_CONSTRAINTS = 2,
  CREATE_TABLE_LIKE_DEFAULTS = 3,
  CREATE_TABLE_LIKE_GENERATED = 4,
  CREATE_TABLE_LIKE_IDENTITY = 5,
  CREATE_TABLE_LIKE_INDEXES = 6,
  CREATE_TABLE_LIKE_STATISTICS = 7,
  CREATE_TABLE_LIKE_STORAGE = 8,
  CREATE_TABLE_LIKE_ALL = 9,
  TableLikeOption_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  TableLikeOption_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool TableLikeOption_IsValid(int value);
constexpr TableLikeOption TableLikeOption_MIN = TABLE_LIKE_OPTION_UNDEFINED;
constexpr TableLikeOption TableLikeOption_MAX = CREATE_TABLE_LIKE_ALL;
constexpr int TableLikeOption_ARRAYSIZE = TableLikeOption_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TableLikeOption_descriptor();
template<typename T>
inline const std::string& TableLikeOption_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TableLikeOption>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TableLikeOption_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TableLikeOption_descriptor(), enum_t_value);
}
inline bool TableLikeOption_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TableLikeOption* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TableLikeOption>(
    TableLikeOption_descriptor(), name, value);
}
enum DefElemAction : int {
  DEF_ELEM_ACTION_UNDEFINED = 0,
  DEFELEM_UNSPEC = 1,
  DEFELEM_SET = 2,
  DEFELEM_ADD = 3,
  DEFELEM_DROP = 4,
  DefElemAction_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  DefElemAction_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool DefElemAction_IsValid(int value);
constexpr DefElemAction DefElemAction_MIN = DEF_ELEM_ACTION_UNDEFINED;
constexpr DefElemAction DefElemAction_MAX = DEFELEM_DROP;
constexpr int DefElemAction_ARRAYSIZE = DefElemAction_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DefElemAction_descriptor();
template<typename T>
inline const std::string& DefElemAction_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DefElemAction>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DefElemAction_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DefElemAction_descriptor(), enum_t_value);
}
inline bool DefElemAction_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DefElemAction* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DefElemAction>(
    DefElemAction_descriptor(), name, value);
}
enum PartitionRangeDatumKind : int {
  PARTITION_RANGE_DATUM_KIND_UNDEFINED = 0,
  PARTITION_RANGE_DATUM_MINVALUE = 1,
  PARTITION_RANGE_DATUM_VALUE = 2,
  PARTITION_RANGE_DATUM_MAXVALUE = 3,
  PartitionRangeDatumKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  PartitionRangeDatumKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool PartitionRangeDatumKind_IsValid(int value);
constexpr PartitionRangeDatumKind PartitionRangeDatumKind_MIN = PARTITION_RANGE_DATUM_KIND_UNDEFINED;
constexpr PartitionRangeDatumKind PartitionRangeDatumKind_MAX = PARTITION_RANGE_DATUM_MAXVALUE;
constexpr int PartitionRangeDatumKind_ARRAYSIZE = PartitionRangeDatumKind_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PartitionRangeDatumKind_descriptor();
template<typename T>
inline const std::string& PartitionRangeDatumKind_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PartitionRangeDatumKind>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PartitionRangeDatumKind_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PartitionRangeDatumKind_descriptor(), enum_t_value);
}
inline bool PartitionRangeDatumKind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PartitionRangeDatumKind* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PartitionRangeDatumKind>(
    PartitionRangeDatumKind_descriptor(), name, value);
}
enum RTEKind : int {
  RTEKIND_UNDEFINED = 0,
  RTE_RELATION = 1,
  RTE_SUBQUERY = 2,
  RTE_JOIN = 3,
  RTE_FUNCTION = 4,
  RTE_TABLEFUNC = 5,
  RTE_VALUES = 6,
  RTE_CTE = 7,
  RTE_NAMEDTUPLESTORE = 8,
  RTE_RESULT = 9,
  RTEKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  RTEKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool RTEKind_IsValid(int value);
constexpr RTEKind RTEKind_MIN = RTEKIND_UNDEFINED;
constexpr RTEKind RTEKind_MAX = RTE_RESULT;
constexpr int RTEKind_ARRAYSIZE = RTEKind_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RTEKind_descriptor();
template<typename T>
inline const std::string& RTEKind_Name(T enum_t_value) {
  static_assert(::std::is_same<T, RTEKind>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function RTEKind_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    RTEKind_descriptor(), enum_t_value);
}
inline bool RTEKind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RTEKind* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RTEKind>(
    RTEKind_descriptor(), name, value);
}
enum WCOKind : int {
  WCOKIND_UNDEFINED = 0,
  WCO_VIEW_CHECK = 1,
  WCO_RLS_INSERT_CHECK = 2,
  WCO_RLS_UPDATE_CHECK = 3,
  WCO_RLS_CONFLICT_CHECK = 4,
  WCOKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  WCOKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool WCOKind_IsValid(int value);
constexpr WCOKind WCOKind_MIN = WCOKIND_UNDEFINED;
constexpr WCOKind WCOKind_MAX = WCO_RLS_CONFLICT_CHECK;
constexpr int WCOKind_ARRAYSIZE = WCOKind_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WCOKind_descriptor();
template<typename T>
inline const std::string& WCOKind_Name(T enum_t_value) {
  static_assert(::std::is_same<T, WCOKind>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function WCOKind_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    WCOKind_descriptor(), enum_t_value);
}
inline bool WCOKind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WCOKind* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WCOKind>(
    WCOKind_descriptor(), name, value);
}
enum GroupingSetKind : int {
  GROUPING_SET_KIND_UNDEFINED = 0,
  GROUPING_SET_EMPTY = 1,
  GROUPING_SET_SIMPLE = 2,
  GROUPING_SET_ROLLUP = 3,
  GROUPING_SET_CUBE = 4,
  GROUPING_SET_SETS = 5,
  GroupingSetKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  GroupingSetKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool GroupingSetKind_IsValid(int value);
constexpr GroupingSetKind GroupingSetKind_MIN = GROUPING_SET_KIND_UNDEFINED;
constexpr GroupingSetKind GroupingSetKind_MAX = GROUPING_SET_SETS;
constexpr int GroupingSetKind_ARRAYSIZE = GroupingSetKind_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GroupingSetKind_descriptor();
template<typename T>
inline const std::string& GroupingSetKind_Name(T enum_t_value) {
  static_assert(::std::is_same<T, GroupingSetKind>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function GroupingSetKind_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    GroupingSetKind_descriptor(), enum_t_value);
}
inline bool GroupingSetKind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GroupingSetKind* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<GroupingSetKind>(
    GroupingSetKind_descriptor(), name, value);
}
enum CTEMaterialize : int {
  CTEMATERIALIZE_UNDEFINED = 0,
  CTEMaterializeDefault = 1,
  CTEMaterializeAlways = 2,
  CTEMaterializeNever = 3,
  CTEMaterialize_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  CTEMaterialize_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool CTEMaterialize_IsValid(int value);
constexpr CTEMaterialize CTEMaterialize_MIN = CTEMATERIALIZE_UNDEFINED;
constexpr CTEMaterialize CTEMaterialize_MAX = CTEMaterializeNever;
constexpr int CTEMaterialize_ARRAYSIZE = CTEMaterialize_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CTEMaterialize_descriptor();
template<typename T>
inline const std::string& CTEMaterialize_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CTEMaterialize>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CTEMaterialize_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CTEMaterialize_descriptor(), enum_t_value);
}
inline bool CTEMaterialize_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CTEMaterialize* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CTEMaterialize>(
    CTEMaterialize_descriptor(), name, value);
}
enum SetOperation : int {
  SET_OPERATION_UNDEFINED = 0,
  SETOP_NONE = 1,
  SETOP_UNION = 2,
  SETOP_INTERSECT = 3,
  SETOP_EXCEPT = 4,
  SetOperation_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  SetOperation_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool SetOperation_IsValid(int value);
constexpr SetOperation SetOperation_MIN = SET_OPERATION_UNDEFINED;
constexpr SetOperation SetOperation_MAX = SETOP_EXCEPT;
constexpr int SetOperation_ARRAYSIZE = SetOperation_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetOperation_descriptor();
template<typename T>
inline const std::string& SetOperation_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SetOperation>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SetOperation_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SetOperation_descriptor(), enum_t_value);
}
inline bool SetOperation_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SetOperation* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SetOperation>(
    SetOperation_descriptor(), name, value);
}
enum ObjectType : int {
  OBJECT_TYPE_UNDEFINED = 0,
  OBJECT_ACCESS_METHOD = 1,
  OBJECT_AGGREGATE = 2,
  OBJECT_AMOP = 3,
  OBJECT_AMPROC = 4,
  OBJECT_ATTRIBUTE = 5,
  OBJECT_CAST = 6,
  OBJECT_COLUMN = 7,
  OBJECT_COLLATION = 8,
  OBJECT_CONVERSION = 9,
  OBJECT_DATABASE = 10,
  OBJECT_DEFAULT = 11,
  OBJECT_DEFACL = 12,
  OBJECT_DOMAIN = 13,
  OBJECT_DOMCONSTRAINT = 14,
  OBJECT_EVENT_TRIGGER = 15,
  OBJECT_EXTENSION = 16,
  OBJECT_FDW = 17,
  OBJECT_FOREIGN_SERVER = 18,
  OBJECT_FOREIGN_TABLE = 19,
  OBJECT_FUNCTION = 20,
  OBJECT_INDEX = 21,
  OBJECT_LANGUAGE = 22,
  OBJECT_LARGEOBJECT = 23,
  OBJECT_MATVIEW = 24,
  OBJECT_OPCLASS = 25,
  OBJECT_OPERATOR = 26,
  OBJECT_OPFAMILY = 27,
  OBJECT_POLICY = 28,
  OBJECT_PROCEDURE = 29,
  OBJECT_PUBLICATION = 30,
  OBJECT_PUBLICATION_REL = 31,
  OBJECT_ROLE = 32,
  OBJECT_ROUTINE = 33,
  OBJECT_RULE = 34,
  OBJECT_SCHEMA = 35,
  OBJECT_SEQUENCE = 36,
  OBJECT_SUBSCRIPTION = 37,
  OBJECT_STATISTIC_EXT = 38,
  OBJECT_TABCONSTRAINT = 39,
  OBJECT_TABLE = 40,
  OBJECT_TABLESPACE = 41,
  OBJECT_TRANSFORM = 42,
  OBJECT_TRIGGER = 43,
  OBJECT_TSCONFIGURATION = 44,
  OBJECT_TSDICTIONARY = 45,
  OBJECT_TSPARSER = 46,
  OBJECT_TSTEMPLATE = 47,
  OBJECT_TYPE = 48,
  OBJECT_USER_MAPPING = 49,
  OBJECT_VIEW = 50,
  ObjectType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  ObjectType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ObjectType_IsValid(int value);
constexpr ObjectType ObjectType_MIN = OBJECT_TYPE_UNDEFINED;
constexpr ObjectType ObjectType_MAX = OBJECT_VIEW;
constexpr int ObjectType_ARRAYSIZE = ObjectType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ObjectType_descriptor();
template<typename T>
inline const std::string& ObjectType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ObjectType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ObjectType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ObjectType_descriptor(), enum_t_value);
}
inline bool ObjectType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ObjectType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ObjectType>(
    ObjectType_descriptor(), name, value);
}
enum DropBehavior : int {
  DROP_BEHAVIOR_UNDEFINED = 0,
  DROP_RESTRICT = 1,
  DROP_CASCADE = 2,
  DropBehavior_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  DropBehavior_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool DropBehavior_IsValid(int value);
constexpr DropBehavior DropBehavior_MIN = DROP_BEHAVIOR_UNDEFINED;
constexpr DropBehavior DropBehavior_MAX = DROP_CASCADE;
constexpr int DropBehavior_ARRAYSIZE = DropBehavior_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DropBehavior_descriptor();
template<typename T>
inline const std::string& DropBehavior_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DropBehavior>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DropBehavior_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DropBehavior_descriptor(), enum_t_value);
}
inline bool DropBehavior_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DropBehavior* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DropBehavior>(
    DropBehavior_descriptor(), name, value);
}
enum AlterTableType : int {
  ALTER_TABLE_TYPE_UNDEFINED = 0,
  AT_AddColumn = 1,
  AT_AddColumnRecurse = 2,
  AT_AddColumnToView = 3,
  AT_ColumnDefault = 4,
  AT_CookedColumnDefault = 5,
  AT_DropNotNull = 6,
  AT_SetNotNull = 7,
  AT_DropExpression = 8,
  AT_CheckNotNull = 9,
  AT_SetStatistics = 10,
  AT_SetOptions = 11,
  AT_ResetOptions = 12,
  AT_SetStorage = 13,
  AT_DropColumn = 14,
  AT_DropColumnRecurse = 15,
  AT_AddIndex = 16,
  AT_ReAddIndex = 17,
  AT_AddConstraint = 18,
  AT_AddConstraintRecurse = 19,
  AT_ReAddConstraint = 20,
  AT_ReAddDomainConstraint = 21,
  AT_AlterConstraint = 22,
  AT_ValidateConstraint = 23,
  AT_ValidateConstraintRecurse = 24,
  AT_AddIndexConstraint = 25,
  AT_DropConstraint = 26,
  AT_DropConstraintRecurse = 27,
  AT_ReAddComment = 28,
  AT_AlterColumnType = 29,
  AT_AlterColumnGenericOptions = 30,
  AT_ChangeOwner = 31,
  AT_ClusterOn = 32,
  AT_DropCluster = 33,
  AT_SetLogged = 34,
  AT_SetUnLogged = 35,
  AT_DropOids = 36,
  AT_SetTableSpace = 37,
  AT_SetRelOptions = 38,
  AT_ResetRelOptions = 39,
  AT_ReplaceRelOptions = 40,
  AT_EnableTrig = 41,
  AT_EnableAlwaysTrig = 42,
  AT_EnableReplicaTrig = 43,
  AT_DisableTrig = 44,
  AT_EnableTrigAll = 45,
  AT_DisableTrigAll = 46,
  AT_EnableTrigUser = 47,
  AT_DisableTrigUser = 48,
  AT_EnableRule = 49,
  AT_EnableAlwaysRule = 50,
  AT_EnableReplicaRule = 51,
  AT_DisableRule = 52,
  AT_AddInherit = 53,
  AT_DropInherit = 54,
  AT_AddOf = 55,
  AT_DropOf = 56,
  AT_ReplicaIdentity = 57,
  AT_EnableRowSecurity = 58,
  AT_DisableRowSecurity = 59,
  AT_ForceRowSecurity = 60,
  AT_NoForceRowSecurity = 61,
  AT_GenericOptions = 62,
  AT_AttachPartition = 63,
  AT_DetachPartition = 64,
  AT_AddIdentity = 65,
  AT_SetIdentity = 66,
  AT_DropIdentity = 67,
  AlterTableType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  AlterTableType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool AlterTableType_IsValid(int value);
constexpr AlterTableType AlterTableType_MIN = ALTER_TABLE_TYPE_UNDEFINED;
constexpr AlterTableType AlterTableType_MAX = AT_DropIdentity;
constexpr int AlterTableType_ARRAYSIZE = AlterTableType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AlterTableType_descriptor();
template<typename T>
inline const std::string& AlterTableType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, AlterTableType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function AlterTableType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    AlterTableType_descriptor(), enum_t_value);
}
inline bool AlterTableType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AlterTableType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AlterTableType>(
    AlterTableType_descriptor(), name, value);
}
enum GrantTargetType : int {
  GRANT_TARGET_TYPE_UNDEFINED = 0,
  ACL_TARGET_OBJECT = 1,
  ACL_TARGET_ALL_IN_SCHEMA = 2,
  ACL_TARGET_DEFAULTS = 3,
  GrantTargetType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  GrantTargetType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool GrantTargetType_IsValid(int value);
constexpr GrantTargetType GrantTargetType_MIN = GRANT_TARGET_TYPE_UNDEFINED;
constexpr GrantTargetType GrantTargetType_MAX = ACL_TARGET_DEFAULTS;
constexpr int GrantTargetType_ARRAYSIZE = GrantTargetType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GrantTargetType_descriptor();
template<typename T>
inline const std::string& GrantTargetType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, GrantTargetType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function GrantTargetType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    GrantTargetType_descriptor(), enum_t_value);
}
inline bool GrantTargetType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GrantTargetType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<GrantTargetType>(
    GrantTargetType_descriptor(), name, value);
}
enum VariableSetKind : int {
  VARIABLE_SET_KIND_UNDEFINED = 0,
  VAR_SET_VALUE = 1,
  VAR_SET_DEFAULT = 2,
  VAR_SET_CURRENT = 3,
  VAR_SET_MULTI = 4,
  VAR_RESET = 5,
  VAR_RESET_ALL = 6,
  VariableSetKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  VariableSetKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool VariableSetKind_IsValid(int value);
constexpr VariableSetKind VariableSetKind_MIN = VARIABLE_SET_KIND_UNDEFINED;
constexpr VariableSetKind VariableSetKind_MAX = VAR_RESET_ALL;
constexpr int VariableSetKind_ARRAYSIZE = VariableSetKind_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* VariableSetKind_descriptor();
template<typename T>
inline const std::string& VariableSetKind_Name(T enum_t_value) {
  static_assert(::std::is_same<T, VariableSetKind>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function VariableSetKind_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    VariableSetKind_descriptor(), enum_t_value);
}
inline bool VariableSetKind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VariableSetKind* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<VariableSetKind>(
    VariableSetKind_descriptor(), name, value);
}
enum ConstrType : int {
  CONSTR_TYPE_UNDEFINED = 0,
  CONSTR_NULL = 1,
  CONSTR_NOTNULL = 2,
  CONSTR_DEFAULT = 3,
  CONSTR_IDENTITY = 4,
  CONSTR_GENERATED = 5,
  CONSTR_CHECK = 6,
  CONSTR_PRIMARY = 7,
  CONSTR_UNIQUE = 8,
  CONSTR_EXCLUSION = 9,
  CONSTR_FOREIGN = 10,
  CONSTR_ATTR_DEFERRABLE = 11,
  CONSTR_ATTR_NOT_DEFERRABLE = 12,
  CONSTR_ATTR_DEFERRED = 13,
  CONSTR_ATTR_IMMEDIATE = 14,
  ConstrType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  ConstrType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ConstrType_IsValid(int value);
constexpr ConstrType ConstrType_MIN = CONSTR_TYPE_UNDEFINED;
constexpr ConstrType ConstrType_MAX = CONSTR_ATTR_IMMEDIATE;
constexpr int ConstrType_ARRAYSIZE = ConstrType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ConstrType_descriptor();
template<typename T>
inline const std::string& ConstrType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ConstrType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ConstrType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ConstrType_descriptor(), enum_t_value);
}
inline bool ConstrType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConstrType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ConstrType>(
    ConstrType_descriptor(), name, value);
}
enum ImportForeignSchemaType : int {
  IMPORT_FOREIGN_SCHEMA_TYPE_UNDEFINED = 0,
  FDW_IMPORT_SCHEMA_ALL = 1,
  FDW_IMPORT_SCHEMA_LIMIT_TO = 2,
  FDW_IMPORT_SCHEMA_EXCEPT = 3,
  ImportForeignSchemaType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  ImportForeignSchemaType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ImportForeignSchemaType_IsValid(int value);
constexpr ImportForeignSchemaType ImportForeignSchemaType_MIN = IMPORT_FOREIGN_SCHEMA_TYPE_UNDEFINED;
constexpr ImportForeignSchemaType ImportForeignSchemaType_MAX = FDW_IMPORT_SCHEMA_EXCEPT;
constexpr int ImportForeignSchemaType_ARRAYSIZE = ImportForeignSchemaType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ImportForeignSchemaType_descriptor();
template<typename T>
inline const std::string& ImportForeignSchemaType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ImportForeignSchemaType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ImportForeignSchemaType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ImportForeignSchemaType_descriptor(), enum_t_value);
}
inline bool ImportForeignSchemaType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ImportForeignSchemaType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ImportForeignSchemaType>(
    ImportForeignSchemaType_descriptor(), name, value);
}
enum RoleStmtType : int {
  ROLE_STMT_TYPE_UNDEFINED = 0,
  ROLESTMT_ROLE = 1,
  ROLESTMT_USER = 2,
  ROLESTMT_GROUP = 3,
  RoleStmtType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  RoleStmtType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool RoleStmtType_IsValid(int value);
constexpr RoleStmtType RoleStmtType_MIN = ROLE_STMT_TYPE_UNDEFINED;
constexpr RoleStmtType RoleStmtType_MAX = ROLESTMT_GROUP;
constexpr int RoleStmtType_ARRAYSIZE = RoleStmtType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RoleStmtType_descriptor();
template<typename T>
inline const std::string& RoleStmtType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, RoleStmtType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function RoleStmtType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    RoleStmtType_descriptor(), enum_t_value);
}
inline bool RoleStmtType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RoleStmtType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RoleStmtType>(
    RoleStmtType_descriptor(), name, value);
}
enum FetchDirection : int {
  FETCH_DIRECTION_UNDEFINED = 0,
  FETCH_FORWARD = 1,
  FETCH_BACKWARD = 2,
  FETCH_ABSOLUTE = 3,
  FETCH_RELATIVE = 4,
  FetchDirection_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  FetchDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool FetchDirection_IsValid(int value);
constexpr FetchDirection FetchDirection_MIN = FETCH_DIRECTION_UNDEFINED;
constexpr FetchDirection FetchDirection_MAX = FETCH_RELATIVE;
constexpr int FetchDirection_ARRAYSIZE = FetchDirection_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FetchDirection_descriptor();
template<typename T>
inline const std::string& FetchDirection_Name(T enum_t_value) {
  static_assert(::std::is_same<T, FetchDirection>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function FetchDirection_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    FetchDirection_descriptor(), enum_t_value);
}
inline bool FetchDirection_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FetchDirection* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FetchDirection>(
    FetchDirection_descriptor(), name, value);
}
enum FunctionParameterMode : int {
  FUNCTION_PARAMETER_MODE_UNDEFINED = 0,
  FUNC_PARAM_IN = 1,
  FUNC_PARAM_OUT = 2,
  FUNC_PARAM_INOUT = 3,
  FUNC_PARAM_VARIADIC = 4,
  FUNC_PARAM_TABLE = 5,
  FunctionParameterMode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  FunctionParameterMode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool FunctionParameterMode_IsValid(int value);
constexpr FunctionParameterMode FunctionParameterMode_MIN = FUNCTION_PARAMETER_MODE_UNDEFINED;
constexpr FunctionParameterMode FunctionParameterMode_MAX = FUNC_PARAM_TABLE;
constexpr int FunctionParameterMode_ARRAYSIZE = FunctionParameterMode_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionParameterMode_descriptor();
template<typename T>
inline const std::string& FunctionParameterMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, FunctionParameterMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function FunctionParameterMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    FunctionParameterMode_descriptor(), enum_t_value);
}
inline bool FunctionParameterMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionParameterMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FunctionParameterMode>(
    FunctionParameterMode_descriptor(), name, value);
}
enum TransactionStmtKind : int {
  TRANSACTION_STMT_KIND_UNDEFINED = 0,
  TRANS_STMT_BEGIN = 1,
  TRANS_STMT_START = 2,
  TRANS_STMT_COMMIT = 3,
  TRANS_STMT_ROLLBACK = 4,
  TRANS_STMT_SAVEPOINT = 5,
  TRANS_STMT_RELEASE = 6,
  TRANS_STMT_ROLLBACK_TO = 7,
  TRANS_STMT_PREPARE = 8,
  TRANS_STMT_COMMIT_PREPARED = 9,
  TRANS_STMT_ROLLBACK_PREPARED = 10,
  TransactionStmtKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  TransactionStmtKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool TransactionStmtKind_IsValid(int value);
constexpr TransactionStmtKind TransactionStmtKind_MIN = TRANSACTION_STMT_KIND_UNDEFINED;
constexpr TransactionStmtKind TransactionStmtKind_MAX = TRANS_STMT_ROLLBACK_PREPARED;
constexpr int TransactionStmtKind_ARRAYSIZE = TransactionStmtKind_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TransactionStmtKind_descriptor();
template<typename T>
inline const std::string& TransactionStmtKind_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TransactionStmtKind>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TransactionStmtKind_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TransactionStmtKind_descriptor(), enum_t_value);
}
inline bool TransactionStmtKind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TransactionStmtKind* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TransactionStmtKind>(
    TransactionStmtKind_descriptor(), name, value);
}
enum ViewCheckOption : int {
  VIEW_CHECK_OPTION_UNDEFINED = 0,
  NO_CHECK_OPTION = 1,
  LOCAL_CHECK_OPTION = 2,
  CASCADED_CHECK_OPTION = 3,
  ViewCheckOption_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  ViewCheckOption_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ViewCheckOption_IsValid(int value);
constexpr ViewCheckOption ViewCheckOption_MIN = VIEW_CHECK_OPTION_UNDEFINED;
constexpr ViewCheckOption ViewCheckOption_MAX = CASCADED_CHECK_OPTION;
constexpr int ViewCheckOption_ARRAYSIZE = ViewCheckOption_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ViewCheckOption_descriptor();
template<typename T>
inline const std::string& ViewCheckOption_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ViewCheckOption>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ViewCheckOption_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ViewCheckOption_descriptor(), enum_t_value);
}
inline bool ViewCheckOption_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ViewCheckOption* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ViewCheckOption>(
    ViewCheckOption_descriptor(), name, value);
}
enum ClusterOption : int {
  CLUSTER_OPTION_UNDEFINED = 0,
  CLUOPT_RECHECK = 1,
  CLUOPT_VERBOSE = 2,
  ClusterOption_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  ClusterOption_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ClusterOption_IsValid(int value);
constexpr ClusterOption ClusterOption_MIN = CLUSTER_OPTION_UNDEFINED;
constexpr ClusterOption ClusterOption_MAX = CLUOPT_VERBOSE;
constexpr int ClusterOption_ARRAYSIZE = ClusterOption_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClusterOption_descriptor();
template<typename T>
inline const std::string& ClusterOption_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ClusterOption>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ClusterOption_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ClusterOption_descriptor(), enum_t_value);
}
inline bool ClusterOption_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClusterOption* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClusterOption>(
    ClusterOption_descriptor(), name, value);
}
enum DiscardMode : int {
  DISCARD_MODE_UNDEFINED = 0,
  DISCARD_ALL = 1,
  DISCARD_PLANS = 2,
  DISCARD_SEQUENCES = 3,
  DISCARD_TEMP = 4,
  DiscardMode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  DiscardMode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool DiscardMode_IsValid(int value);
constexpr DiscardMode DiscardMode_MIN = DISCARD_MODE_UNDEFINED;
constexpr DiscardMode DiscardMode_MAX = DISCARD_TEMP;
constexpr int DiscardMode_ARRAYSIZE = DiscardMode_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DiscardMode_descriptor();
template<typename T>
inline const std::string& DiscardMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DiscardMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DiscardMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DiscardMode_descriptor(), enum_t_value);
}
inline bool DiscardMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DiscardMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DiscardMode>(
    DiscardMode_descriptor(), name, value);
}
enum ReindexObjectType : int {
  REINDEX_OBJECT_TYPE_UNDEFINED = 0,
  REINDEX_OBJECT_INDEX = 1,
  REINDEX_OBJECT_TABLE = 2,
  REINDEX_OBJECT_SCHEMA = 3,
  REINDEX_OBJECT_SYSTEM = 4,
  REINDEX_OBJECT_DATABASE = 5,
  ReindexObjectType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  ReindexObjectType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ReindexObjectType_IsValid(int value);
constexpr ReindexObjectType ReindexObjectType_MIN = REINDEX_OBJECT_TYPE_UNDEFINED;
constexpr ReindexObjectType ReindexObjectType_MAX = REINDEX_OBJECT_DATABASE;
constexpr int ReindexObjectType_ARRAYSIZE = ReindexObjectType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReindexObjectType_descriptor();
template<typename T>
inline const std::string& ReindexObjectType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ReindexObjectType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ReindexObjectType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ReindexObjectType_descriptor(), enum_t_value);
}
inline bool ReindexObjectType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReindexObjectType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ReindexObjectType>(
    ReindexObjectType_descriptor(), name, value);
}
enum AlterTSConfigType : int {
  ALTER_TSCONFIG_TYPE_UNDEFINED = 0,
  ALTER_TSCONFIG_ADD_MAPPING = 1,
  ALTER_TSCONFIG_ALTER_MAPPING_FOR_TOKEN = 2,
  ALTER_TSCONFIG_REPLACE_DICT = 3,
  ALTER_TSCONFIG_REPLACE_DICT_FOR_TOKEN = 4,
  ALTER_TSCONFIG_DROP_MAPPING = 5,
  AlterTSConfigType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  AlterTSConfigType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool AlterTSConfigType_IsValid(int value);
constexpr AlterTSConfigType AlterTSConfigType_MIN = ALTER_TSCONFIG_TYPE_UNDEFINED;
constexpr AlterTSConfigType AlterTSConfigType_MAX = ALTER_TSCONFIG_DROP_MAPPING;
constexpr int AlterTSConfigType_ARRAYSIZE = AlterTSConfigType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AlterTSConfigType_descriptor();
template<typename T>
inline const std::string& AlterTSConfigType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, AlterTSConfigType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function AlterTSConfigType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    AlterTSConfigType_descriptor(), enum_t_value);
}
inline bool AlterTSConfigType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AlterTSConfigType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AlterTSConfigType>(
    AlterTSConfigType_descriptor(), name, value);
}
enum AlterSubscriptionType : int {
  ALTER_SUBSCRIPTION_TYPE_UNDEFINED = 0,
  ALTER_SUBSCRIPTION_OPTIONS = 1,
  ALTER_SUBSCRIPTION_CONNECTION = 2,
  ALTER_SUBSCRIPTION_PUBLICATION = 3,
  ALTER_SUBSCRIPTION_REFRESH = 4,
  ALTER_SUBSCRIPTION_ENABLED = 5,
  AlterSubscriptionType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  AlterSubscriptionType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool AlterSubscriptionType_IsValid(int value);
constexpr AlterSubscriptionType AlterSubscriptionType_MIN = ALTER_SUBSCRIPTION_TYPE_UNDEFINED;
constexpr AlterSubscriptionType AlterSubscriptionType_MAX = ALTER_SUBSCRIPTION_ENABLED;
constexpr int AlterSubscriptionType_ARRAYSIZE = AlterSubscriptionType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AlterSubscriptionType_descriptor();
template<typename T>
inline const std::string& AlterSubscriptionType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, AlterSubscriptionType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function AlterSubscriptionType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    AlterSubscriptionType_descriptor(), enum_t_value);
}
inline bool AlterSubscriptionType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AlterSubscriptionType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AlterSubscriptionType>(
    AlterSubscriptionType_descriptor(), name, value);
}
enum OnCommitAction : int {
  ON_COMMIT_ACTION_UNDEFINED = 0,
  ONCOMMIT_NOOP = 1,
  ONCOMMIT_PRESERVE_ROWS = 2,
  ONCOMMIT_DELETE_ROWS = 3,
  ONCOMMIT_DROP = 4,
  OnCommitAction_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  OnCommitAction_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool OnCommitAction_IsValid(int value);
constexpr OnCommitAction OnCommitAction_MIN = ON_COMMIT_ACTION_UNDEFINED;
constexpr OnCommitAction OnCommitAction_MAX = ONCOMMIT_DROP;
constexpr int OnCommitAction_ARRAYSIZE = OnCommitAction_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OnCommitAction_descriptor();
template<typename T>
inline const std::string& OnCommitAction_Name(T enum_t_value) {
  static_assert(::std::is_same<T, OnCommitAction>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function OnCommitAction_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    OnCommitAction_descriptor(), enum_t_value);
}
inline bool OnCommitAction_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OnCommitAction* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<OnCommitAction>(
    OnCommitAction_descriptor(), name, value);
}
enum ParamKind : int {
  PARAM_KIND_UNDEFINED = 0,
  PARAM_EXTERN = 1,
  PARAM_EXEC = 2,
  PARAM_SUBLINK = 3,
  PARAM_MULTIEXPR = 4,
  ParamKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  ParamKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ParamKind_IsValid(int value);
constexpr ParamKind ParamKind_MIN = PARAM_KIND_UNDEFINED;
constexpr ParamKind ParamKind_MAX = PARAM_MULTIEXPR;
constexpr int ParamKind_ARRAYSIZE = ParamKind_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ParamKind_descriptor();
template<typename T>
inline const std::string& ParamKind_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ParamKind>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ParamKind_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ParamKind_descriptor(), enum_t_value);
}
inline bool ParamKind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ParamKind* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ParamKind>(
    ParamKind_descriptor(), name, value);
}
enum CoercionContext : int {
  COERCION_CONTEXT_UNDEFINED = 0,
  COERCION_IMPLICIT = 1,
  COERCION_ASSIGNMENT = 2,
  COERCION_EXPLICIT = 3,
  CoercionContext_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  CoercionContext_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool CoercionContext_IsValid(int value);
constexpr CoercionContext CoercionContext_MIN = COERCION_CONTEXT_UNDEFINED;
constexpr CoercionContext CoercionContext_MAX = COERCION_EXPLICIT;
constexpr int CoercionContext_ARRAYSIZE = CoercionContext_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CoercionContext_descriptor();
template<typename T>
inline const std::string& CoercionContext_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CoercionContext>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CoercionContext_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CoercionContext_descriptor(), enum_t_value);
}
inline bool CoercionContext_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CoercionContext* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CoercionContext>(
    CoercionContext_descriptor(), name, value);
}
enum CoercionForm : int {
  COERCION_FORM_UNDEFINED = 0,
  COERCE_EXPLICIT_CALL = 1,
  COERCE_EXPLICIT_CAST = 2,
  COERCE_IMPLICIT_CAST = 3,
  CoercionForm_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  CoercionForm_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool CoercionForm_IsValid(int value);
constexpr CoercionForm CoercionForm_MIN = COERCION_FORM_UNDEFINED;
constexpr CoercionForm CoercionForm_MAX = COERCE_IMPLICIT_CAST;
constexpr int CoercionForm_ARRAYSIZE = CoercionForm_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CoercionForm_descriptor();
template<typename T>
inline const std::string& CoercionForm_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CoercionForm>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CoercionForm_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CoercionForm_descriptor(), enum_t_value);
}
inline bool CoercionForm_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CoercionForm* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CoercionForm>(
    CoercionForm_descriptor(), name, value);
}
enum BoolExprType : int {
  BOOL_EXPR_TYPE_UNDEFINED = 0,
  AND_EXPR = 1,
  OR_EXPR = 2,
  NOT_EXPR = 3,
  BoolExprType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  BoolExprType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool BoolExprType_IsValid(int value);
constexpr BoolExprType BoolExprType_MIN = BOOL_EXPR_TYPE_UNDEFINED;
constexpr BoolExprType BoolExprType_MAX = NOT_EXPR;
constexpr int BoolExprType_ARRAYSIZE = BoolExprType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BoolExprType_descriptor();
template<typename T>
inline const std::string& BoolExprType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, BoolExprType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function BoolExprType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    BoolExprType_descriptor(), enum_t_value);
}
inline bool BoolExprType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BoolExprType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BoolExprType>(
    BoolExprType_descriptor(), name, value);
}
enum SubLinkType : int {
  SUB_LINK_TYPE_UNDEFINED = 0,
  EXISTS_SUBLINK = 1,
  ALL_SUBLINK = 2,
  ANY_SUBLINK = 3,
  ROWCOMPARE_SUBLINK = 4,
  EXPR_SUBLINK = 5,
  MULTIEXPR_SUBLINK = 6,
  ARRAY_SUBLINK = 7,
  CTE_SUBLINK = 8,
  SubLinkType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  SubLinkType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool SubLinkType_IsValid(int value);
constexpr SubLinkType SubLinkType_MIN = SUB_LINK_TYPE_UNDEFINED;
constexpr SubLinkType SubLinkType_MAX = CTE_SUBLINK;
constexpr int SubLinkType_ARRAYSIZE = SubLinkType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SubLinkType_descriptor();
template<typename T>
inline const std::string& SubLinkType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SubLinkType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SubLinkType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SubLinkType_descriptor(), enum_t_value);
}
inline bool SubLinkType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SubLinkType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SubLinkType>(
    SubLinkType_descriptor(), name, value);
}
enum RowCompareType : int {
  ROW_COMPARE_TYPE_UNDEFINED = 0,
  ROWCOMPARE_LT = 1,
  ROWCOMPARE_LE = 2,
  ROWCOMPARE_EQ = 3,
  ROWCOMPARE_GE = 4,
  ROWCOMPARE_GT = 5,
  ROWCOMPARE_NE = 6,
  RowCompareType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  RowCompareType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool RowCompareType_IsValid(int value);
constexpr RowCompareType RowCompareType_MIN = ROW_COMPARE_TYPE_UNDEFINED;
constexpr RowCompareType RowCompareType_MAX = ROWCOMPARE_NE;
constexpr int RowCompareType_ARRAYSIZE = RowCompareType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RowCompareType_descriptor();
template<typename T>
inline const std::string& RowCompareType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, RowCompareType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function RowCompareType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    RowCompareType_descriptor(), enum_t_value);
}
inline bool RowCompareType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RowCompareType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RowCompareType>(
    RowCompareType_descriptor(), name, value);
}
enum MinMaxOp : int {
  MIN_MAX_OP_UNDEFINED = 0,
  IS_GREATEST = 1,
  IS_LEAST = 2,
  MinMaxOp_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  MinMaxOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool MinMaxOp_IsValid(int value);
constexpr MinMaxOp MinMaxOp_MIN = MIN_MAX_OP_UNDEFINED;
constexpr MinMaxOp MinMaxOp_MAX = IS_LEAST;
constexpr int MinMaxOp_ARRAYSIZE = MinMaxOp_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MinMaxOp_descriptor();
template<typename T>
inline const std::string& MinMaxOp_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MinMaxOp>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MinMaxOp_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MinMaxOp_descriptor(), enum_t_value);
}
inline bool MinMaxOp_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MinMaxOp* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MinMaxOp>(
    MinMaxOp_descriptor(), name, value);
}
enum SQLValueFunctionOp : int {
  SQLVALUE_FUNCTION_OP_UNDEFINED = 0,
  SVFOP_CURRENT_DATE = 1,
  SVFOP_CURRENT_TIME = 2,
  SVFOP_CURRENT_TIME_N = 3,
  SVFOP_CURRENT_TIMESTAMP = 4,
  SVFOP_CURRENT_TIMESTAMP_N = 5,
  SVFOP_LOCALTIME = 6,
  SVFOP_LOCALTIME_N = 7,
  SVFOP_LOCALTIMESTAMP = 8,
  SVFOP_LOCALTIMESTAMP_N = 9,
  SVFOP_CURRENT_ROLE = 10,
  SVFOP_CURRENT_USER = 11,
  SVFOP_USER = 12,
  SVFOP_SESSION_USER = 13,
  SVFOP_CURRENT_CATALOG = 14,
  SVFOP_CURRENT_SCHEMA = 15,
  SQLValueFunctionOp_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  SQLValueFunctionOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool SQLValueFunctionOp_IsValid(int value);
constexpr SQLValueFunctionOp SQLValueFunctionOp_MIN = SQLVALUE_FUNCTION_OP_UNDEFINED;
constexpr SQLValueFunctionOp SQLValueFunctionOp_MAX = SVFOP_CURRENT_SCHEMA;
constexpr int SQLValueFunctionOp_ARRAYSIZE = SQLValueFunctionOp_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SQLValueFunctionOp_descriptor();
template<typename T>
inline const std::string& SQLValueFunctionOp_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SQLValueFunctionOp>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SQLValueFunctionOp_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SQLValueFunctionOp_descriptor(), enum_t_value);
}
inline bool SQLValueFunctionOp_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SQLValueFunctionOp* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SQLValueFunctionOp>(
    SQLValueFunctionOp_descriptor(), name, value);
}
enum XmlExprOp : int {
  XML_EXPR_OP_UNDEFINED = 0,
  IS_XMLCONCAT = 1,
  IS_XMLELEMENT = 2,
  IS_XMLFOREST = 3,
  IS_XMLPARSE = 4,
  IS_XMLPI = 5,
  IS_XMLROOT = 6,
  IS_XMLSERIALIZE = 7,
  IS_DOCUMENT = 8,
  XmlExprOp_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  XmlExprOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool XmlExprOp_IsValid(int value);
constexpr XmlExprOp XmlExprOp_MIN = XML_EXPR_OP_UNDEFINED;
constexpr XmlExprOp XmlExprOp_MAX = IS_DOCUMENT;
constexpr int XmlExprOp_ARRAYSIZE = XmlExprOp_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* XmlExprOp_descriptor();
template<typename T>
inline const std::string& XmlExprOp_Name(T enum_t_value) {
  static_assert(::std::is_same<T, XmlExprOp>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function XmlExprOp_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    XmlExprOp_descriptor(), enum_t_value);
}
inline bool XmlExprOp_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, XmlExprOp* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<XmlExprOp>(
    XmlExprOp_descriptor(), name, value);
}
enum XmlOptionType : int {
  XML_OPTION_TYPE_UNDEFINED = 0,
  XMLOPTION_DOCUMENT = 1,
  XMLOPTION_CONTENT = 2,
  XmlOptionType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  XmlOptionType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool XmlOptionType_IsValid(int value);
constexpr XmlOptionType XmlOptionType_MIN = XML_OPTION_TYPE_UNDEFINED;
constexpr XmlOptionType XmlOptionType_MAX = XMLOPTION_CONTENT;
constexpr int XmlOptionType_ARRAYSIZE = XmlOptionType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* XmlOptionType_descriptor();
template<typename T>
inline const std::string& XmlOptionType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, XmlOptionType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function XmlOptionType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    XmlOptionType_descriptor(), enum_t_value);
}
inline bool XmlOptionType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, XmlOptionType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<XmlOptionType>(
    XmlOptionType_descriptor(), name, value);
}
enum NullTestType : int {
  NULL_TEST_TYPE_UNDEFINED = 0,
  IS_NULL = 1,
  IS_NOT_NULL = 2,
  NullTestType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  NullTestType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool NullTestType_IsValid(int value);
constexpr NullTestType NullTestType_MIN = NULL_TEST_TYPE_UNDEFINED;
constexpr NullTestType NullTestType_MAX = IS_NOT_NULL;
constexpr int NullTestType_ARRAYSIZE = NullTestType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NullTestType_descriptor();
template<typename T>
inline const std::string& NullTestType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, NullTestType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function NullTestType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    NullTestType_descriptor(), enum_t_value);
}
inline bool NullTestType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NullTestType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NullTestType>(
    NullTestType_descriptor(), name, value);
}
enum BoolTestType : int {
  BOOL_TEST_TYPE_UNDEFINED = 0,
  IS_TRUE = 1,
  IS_NOT_TRUE = 2,
  IS_FALSE = 3,
  IS_NOT_FALSE = 4,
  IS_UNKNOWN = 5,
  IS_NOT_UNKNOWN = 6,
  BoolTestType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  BoolTestType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool BoolTestType_IsValid(int value);
constexpr BoolTestType BoolTestType_MIN = BOOL_TEST_TYPE_UNDEFINED;
constexpr BoolTestType BoolTestType_MAX = IS_NOT_UNKNOWN;
constexpr int BoolTestType_ARRAYSIZE = BoolTestType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BoolTestType_descriptor();
template<typename T>
inline const std::string& BoolTestType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, BoolTestType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function BoolTestType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    BoolTestType_descriptor(), enum_t_value);
}
inline bool BoolTestType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BoolTestType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BoolTestType>(
    BoolTestType_descriptor(), name, value);
}
enum CmdType : int {
  CMD_TYPE_UNDEFINED = 0,
  CMD_UNKNOWN = 1,
  CMD_SELECT = 2,
  CMD_UPDATE = 3,
  CMD_INSERT = 4,
  CMD_DELETE = 5,
  CMD_UTILITY = 6,
  CMD_NOTHING = 7,
  CmdType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  CmdType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool CmdType_IsValid(int value);
constexpr CmdType CmdType_MIN = CMD_TYPE_UNDEFINED;
constexpr CmdType CmdType_MAX = CMD_NOTHING;
constexpr int CmdType_ARRAYSIZE = CmdType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CmdType_descriptor();
template<typename T>
inline const std::string& CmdType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CmdType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CmdType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CmdType_descriptor(), enum_t_value);
}
inline bool CmdType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CmdType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CmdType>(
    CmdType_descriptor(), name, value);
}
enum JoinType : int {
  JOIN_TYPE_UNDEFINED = 0,
  JOIN_INNER = 1,
  JOIN_LEFT = 2,
  JOIN_FULL = 3,
  JOIN_RIGHT = 4,
  JOIN_SEMI = 5,
  JOIN_ANTI = 6,
  JOIN_UNIQUE_OUTER = 7,
  JOIN_UNIQUE_INNER = 8,
  JoinType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  JoinType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool JoinType_IsValid(int value);
constexpr JoinType JoinType_MIN = JOIN_TYPE_UNDEFINED;
constexpr JoinType JoinType_MAX = JOIN_UNIQUE_INNER;
constexpr int JoinType_ARRAYSIZE = JoinType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JoinType_descriptor();
template<typename T>
inline const std::string& JoinType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, JoinType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function JoinType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    JoinType_descriptor(), enum_t_value);
}
inline bool JoinType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, JoinType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<JoinType>(
    JoinType_descriptor(), name, value);
}
enum AggStrategy : int {
  AGG_STRATEGY_UNDEFINED = 0,
  AGG_PLAIN = 1,
  AGG_SORTED = 2,
  AGG_HASHED = 3,
  AGG_MIXED = 4,
  AggStrategy_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  AggStrategy_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool AggStrategy_IsValid(int value);
constexpr AggStrategy AggStrategy_MIN = AGG_STRATEGY_UNDEFINED;
constexpr AggStrategy AggStrategy_MAX = AGG_MIXED;
constexpr int AggStrategy_ARRAYSIZE = AggStrategy_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggStrategy_descriptor();
template<typename T>
inline const std::string& AggStrategy_Name(T enum_t_value) {
  static_assert(::std::is_same<T, AggStrategy>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function AggStrategy_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    AggStrategy_descriptor(), enum_t_value);
}
inline bool AggStrategy_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AggStrategy* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AggStrategy>(
    AggStrategy_descriptor(), name, value);
}
enum AggSplit : int {
  AGG_SPLIT_UNDEFINED = 0,
  AGGSPLIT_SIMPLE = 1,
  AGGSPLIT_INITIAL_SERIAL = 2,
  AGGSPLIT_FINAL_DESERIAL = 3,
  AggSplit_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  AggSplit_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool AggSplit_IsValid(int value);
constexpr AggSplit AggSplit_MIN = AGG_SPLIT_UNDEFINED;
constexpr AggSplit AggSplit_MAX = AGGSPLIT_FINAL_DESERIAL;
constexpr int AggSplit_ARRAYSIZE = AggSplit_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggSplit_descriptor();
template<typename T>
inline const std::string& AggSplit_Name(T enum_t_value) {
  static_assert(::std::is_same<T, AggSplit>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function AggSplit_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    AggSplit_descriptor(), enum_t_value);
}
inline bool AggSplit_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AggSplit* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AggSplit>(
    AggSplit_descriptor(), name, value);
}
enum SetOpCmd : int {
  SET_OP_CMD_UNDEFINED = 0,
  SETOPCMD_INTERSECT = 1,
  SETOPCMD_INTERSECT_ALL = 2,
  SETOPCMD_EXCEPT = 3,
  SETOPCMD_EXCEPT_ALL = 4,
  SetOpCmd_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  SetOpCmd_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool SetOpCmd_IsValid(int value);
constexpr SetOpCmd SetOpCmd_MIN = SET_OP_CMD_UNDEFINED;
constexpr SetOpCmd SetOpCmd_MAX = SETOPCMD_EXCEPT_ALL;
constexpr int SetOpCmd_ARRAYSIZE = SetOpCmd_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetOpCmd_descriptor();
template<typename T>
inline const std::string& SetOpCmd_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SetOpCmd>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SetOpCmd_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SetOpCmd_descriptor(), enum_t_value);
}
inline bool SetOpCmd_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SetOpCmd* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SetOpCmd>(
    SetOpCmd_descriptor(), name, value);
}
enum SetOpStrategy : int {
  SET_OP_STRATEGY_UNDEFINED = 0,
  SETOP_SORTED = 1,
  SETOP_HASHED = 2,
  SetOpStrategy_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  SetOpStrategy_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool SetOpStrategy_IsValid(int value);
constexpr SetOpStrategy SetOpStrategy_MIN = SET_OP_STRATEGY_UNDEFINED;
constexpr SetOpStrategy SetOpStrategy_MAX = SETOP_HASHED;
constexpr int SetOpStrategy_ARRAYSIZE = SetOpStrategy_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetOpStrategy_descriptor();
template<typename T>
inline const std::string& SetOpStrategy_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SetOpStrategy>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SetOpStrategy_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SetOpStrategy_descriptor(), enum_t_value);
}
inline bool SetOpStrategy_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SetOpStrategy* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SetOpStrategy>(
    SetOpStrategy_descriptor(), name, value);
}
enum OnConflictAction : int {
  ON_CONFLICT_ACTION_UNDEFINED = 0,
  ONCONFLICT_NONE = 1,
  ONCONFLICT_NOTHING = 2,
  ONCONFLICT_UPDATE = 3,
  OnConflictAction_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  OnConflictAction_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool OnConflictAction_IsValid(int value);
constexpr OnConflictAction OnConflictAction_MIN = ON_CONFLICT_ACTION_UNDEFINED;
constexpr OnConflictAction OnConflictAction_MAX = ONCONFLICT_UPDATE;
constexpr int OnConflictAction_ARRAYSIZE = OnConflictAction_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OnConflictAction_descriptor();
template<typename T>
inline const std::string& OnConflictAction_Name(T enum_t_value) {
  static_assert(::std::is_same<T, OnConflictAction>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function OnConflictAction_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    OnConflictAction_descriptor(), enum_t_value);
}
inline bool OnConflictAction_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OnConflictAction* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<OnConflictAction>(
    OnConflictAction_descriptor(), name, value);
}
enum LimitOption : int {
  LIMIT_OPTION_UNDEFINED = 0,
  LIMIT_OPTION_DEFAULT = 1,
  LIMIT_OPTION_COUNT = 2,
  LIMIT_OPTION_WITH_TIES = 3,
  LimitOption_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  LimitOption_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool LimitOption_IsValid(int value);
constexpr LimitOption LimitOption_MIN = LIMIT_OPTION_UNDEFINED;
constexpr LimitOption LimitOption_MAX = LIMIT_OPTION_WITH_TIES;
constexpr int LimitOption_ARRAYSIZE = LimitOption_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LimitOption_descriptor();
template<typename T>
inline const std::string& LimitOption_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LimitOption>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LimitOption_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LimitOption_descriptor(), enum_t_value);
}
inline bool LimitOption_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LimitOption* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LimitOption>(
    LimitOption_descriptor(), name, value);
}
enum LockClauseStrength : int {
  LOCK_CLAUSE_STRENGTH_UNDEFINED = 0,
  LCS_NONE = 1,
  LCS_FORKEYSHARE = 2,
  LCS_FORSHARE = 3,
  LCS_FORNOKEYUPDATE = 4,
  LCS_FORUPDATE = 5,
  LockClauseStrength_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  LockClauseStrength_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool LockClauseStrength_IsValid(int value);
constexpr LockClauseStrength LockClauseStrength_MIN = LOCK_CLAUSE_STRENGTH_UNDEFINED;
constexpr LockClauseStrength LockClauseStrength_MAX = LCS_FORUPDATE;
constexpr int LockClauseStrength_ARRAYSIZE = LockClauseStrength_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LockClauseStrength_descriptor();
template<typename T>
inline const std::string& LockClauseStrength_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LockClauseStrength>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LockClauseStrength_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LockClauseStrength_descriptor(), enum_t_value);
}
inline bool LockClauseStrength_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LockClauseStrength* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LockClauseStrength>(
    LockClauseStrength_descriptor(), name, value);
}
enum LockWaitPolicy : int {
  LOCK_WAIT_POLICY_UNDEFINED = 0,
  LockWaitBlock = 1,
  LockWaitSkip = 2,
  LockWaitError = 3,
  LockWaitPolicy_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  LockWaitPolicy_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool LockWaitPolicy_IsValid(int value);
constexpr LockWaitPolicy LockWaitPolicy_MIN = LOCK_WAIT_POLICY_UNDEFINED;
constexpr LockWaitPolicy LockWaitPolicy_MAX = LockWaitError;
constexpr int LockWaitPolicy_ARRAYSIZE = LockWaitPolicy_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LockWaitPolicy_descriptor();
template<typename T>
inline const std::string& LockWaitPolicy_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LockWaitPolicy>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LockWaitPolicy_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LockWaitPolicy_descriptor(), enum_t_value);
}
inline bool LockWaitPolicy_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LockWaitPolicy* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LockWaitPolicy>(
    LockWaitPolicy_descriptor(), name, value);
}
enum LockTupleMode : int {
  LOCK_TUPLE_MODE_UNDEFINED = 0,
  LockTupleKeyShare = 1,
  LockTupleShare = 2,
  LockTupleNoKeyExclusive = 3,
  LockTupleExclusive = 4,
  LockTupleMode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  LockTupleMode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool LockTupleMode_IsValid(int value);
constexpr LockTupleMode LockTupleMode_MIN = LOCK_TUPLE_MODE_UNDEFINED;
constexpr LockTupleMode LockTupleMode_MAX = LockTupleExclusive;
constexpr int LockTupleMode_ARRAYSIZE = LockTupleMode_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LockTupleMode_descriptor();
template<typename T>
inline const std::string& LockTupleMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LockTupleMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LockTupleMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LockTupleMode_descriptor(), enum_t_value);
}
inline bool LockTupleMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LockTupleMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LockTupleMode>(
    LockTupleMode_descriptor(), name, value);
}
enum KeywordKind : int {
  NO_KEYWORD = 0,
  UNRESERVED_KEYWORD = 1,
  COL_NAME_KEYWORD = 2,
  TYPE_FUNC_NAME_KEYWORD = 3,
  RESERVED_KEYWORD = 4,
  KeywordKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  KeywordKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool KeywordKind_IsValid(int value);
constexpr KeywordKind KeywordKind_MIN = NO_KEYWORD;
constexpr KeywordKind KeywordKind_MAX = RESERVED_KEYWORD;
constexpr int KeywordKind_ARRAYSIZE = KeywordKind_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeywordKind_descriptor();
template<typename T>
inline const std::string& KeywordKind_Name(T enum_t_value) {
  static_assert(::std::is_same<T, KeywordKind>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function KeywordKind_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    KeywordKind_descriptor(), enum_t_value);
}
inline bool KeywordKind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, KeywordKind* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<KeywordKind>(
    KeywordKind_descriptor(), name, value);
}
enum Token : int {
  NUL = 0,
  ASCII_37 = 37,
  ASCII_40 = 40,
  ASCII_41 = 41,
  ASCII_42 = 42,
  ASCII_43 = 43,
  ASCII_44 = 44,
  ASCII_45 = 45,
  ASCII_46 = 46,
  ASCII_47 = 47,
  ASCII_58 = 58,
  ASCII_59 = 59,
  ASCII_60 = 60,
  ASCII_61 = 61,
  ASCII_62 = 62,
  ASCII_63 = 63,
  ASCII_91 = 91,
  ASCII_93 = 93,
  ASCII_94 = 94,
  IDENT = 258,
  UIDENT = 259,
  FCONST = 260,
  SCONST = 261,
  USCONST = 262,
  BCONST = 263,
  XCONST = 264,
  Op = 265,
  ICONST = 266,
  PARAM = 267,
  TYPECAST = 268,
  DOT_DOT = 269,
  COLON_EQUALS = 270,
  EQUALS_GREATER = 271,
  LESS_EQUALS = 272,
  GREATER_EQUALS = 273,
  NOT_EQUALS = 274,
  SQL_COMMENT = 275,
  C_COMMENT = 276,
  ABORT_P = 277,
  ABSOLUTE_P = 278,
  ACCESS = 279,
  ACTION = 280,
  ADD_P = 281,
  ADMIN = 282,
  AFTER = 283,
  AGGREGATE = 284,
  ALL = 285,
  ALSO = 286,
  ALTER = 287,
  ALWAYS = 288,
  ANALYSE = 289,
  ANALYZE = 290,
  AND = 291,
  ANY = 292,
  ARRAY = 293,
  AS = 294,
  ASC = 295,
  ASSERTION = 296,
  ASSIGNMENT = 297,
  ASYMMETRIC = 298,
  AT = 299,
  ATTACH = 300,
  ATTRIBUTE = 301,
  AUTHORIZATION = 302,
  BACKWARD = 303,
  BEFORE = 304,
  BEGIN_P = 305,
  BETWEEN = 306,
  BIGINT = 307,
  BINARY = 308,
  BIT = 309,
  BOOLEAN_P = 310,
  BOTH = 311,
  BY = 312,
  CACHE = 313,
  CALL = 314,
  CALLED = 315,
  CASCADE = 316,
  CASCADED = 317,
  CASE = 318,
  CAST = 319,
  CATALOG_P = 320,
  CHAIN = 321,
  CHAR_P = 322,
  CHARACTER = 323,
  CHARACTERISTICS = 324,
  CHECK = 325,
  CHECKPOINT = 326,
  CLASS = 327,
  CLOSE = 328,
  CLUSTER = 329,
  COALESCE = 330,
  COLLATE = 331,
  COLLATION = 332,
  COLUMN = 333,
  COLUMNS = 334,
  COMMENT = 335,
  COMMENTS = 336,
  COMMIT = 337,
  COMMITTED = 338,
  CONCURRENTLY = 339,
  CONFIGURATION = 340,
  CONFLICT = 341,
  CONNECTION = 342,
  CONSTRAINT = 343,
  CONSTRAINTS = 344,
  CONTENT_P = 345,
  CONTINUE_P = 346,
  CONVERSION_P = 347,
  COPY = 348,
  COST = 349,
  CREATE = 350,
  CROSS = 351,
  CSV = 352,
  CUBE = 353,
  CURRENT_P = 354,
  CURRENT_CATALOG = 355,
  CURRENT_DATE = 356,
  CURRENT_ROLE = 357,
  CURRENT_SCHEMA = 358,
  CURRENT_TIME = 359,
  CURRENT_TIMESTAMP = 360,
  CURRENT_USER = 361,
  CURSOR = 362,
  CYCLE = 363,
  DATA_P = 364,
  DATABASE = 365,
  DAY_P = 366,
  DEALLOCATE = 367,
  DEC = 368,
  DECIMAL_P = 369,
  DECLARE = 370,
  DEFAULT = 371,
  DEFAULTS = 372,
  DEFERRABLE = 373,
  DEFERRED = 374,
  DEFINER = 375,
  DELETE_P = 376,
  DELIMITER = 377,
  DELIMITERS = 378,
  DEPENDS = 379,
  DESC = 380,
  DETACH = 381,
  DICTIONARY = 382,
  DISABLE_P = 383,
  DISCARD = 384,
  DISTINCT = 385,
  DO = 386,
  DOCUMENT_P = 387,
  DOMAIN_P = 388,
  DOUBLE_P = 389,
  DROP = 390,
  EACH = 391,
  ELSE = 392,
  ENABLE_P = 393,
  ENCODING = 394,
  ENCRYPTED = 395,
  END_P = 396,
  ENUM_P = 397,
  ESCAPE = 398,
  EVENT = 399,
  EXCEPT = 400,
  EXCLUDE = 401,
  EXCLUDING = 402,
  EXCLUSIVE = 403,
  EXECUTE = 404,
  EXISTS = 405,
  EXPLAIN = 406,
  EXPRESSION = 407,
  EXTENSION = 408,
  EXTERNAL = 409,
  EXTRACT = 410,
  FALSE_P = 411,
  FAMILY = 412,
  FETCH = 413,
  FILTER = 414,
  FIRST_P = 415,
  FLOAT_P = 416,
  FOLLOWING = 417,
  FOR = 418,
  FORCE = 419,
  FOREIGN = 420,
  FORWARD = 421,
  FREEZE = 422,
  FROM = 423,
  FULL = 424,
  FUNCTION = 425,
  FUNCTIONS = 426,
  GENERATED = 427,
  GLOBAL = 428,
  GRANT = 429,
  GRANTED = 430,
  GREATEST = 431,
  GROUP_P = 432,
  GROUPING = 433,
  GROUPS = 434,
  HANDLER = 435,
  HAVING = 436,
  HEADER_P = 437,
  HOLD = 438,
  HOUR_P = 439,
  IDENTITY_P = 440,
  IF_P = 441,
  ILIKE = 442,
  IMMEDIATE = 443,
  IMMUTABLE = 444,
  IMPLICIT_P = 445,
  IMPORT_P = 446,
  IN_P = 447,
  INCLUDE = 448,
  INCLUDING = 449,
  INCREMENT = 450,
  INDEX = 451,
  INDEXES = 452,
  INHERIT = 453,
  INHERITS = 454,
  INITIALLY = 455,
  INLINE_P = 456,
  INNER_P = 457,
  INOUT = 458,
  INPUT_P = 459,
  INSENSITIVE = 460,
  INSERT = 461,
  INSTEAD = 462,
  INT_P = 463,
  INTEGER = 464,
  INTERSECT = 465,
  INTERVAL = 466,
  INTO = 467,
  INVOKER = 468,
  IS = 469,
  ISNULL = 470,
  ISOLATION = 471,
  JOIN = 472,
  KEY = 473,
  LABEL = 474,
  LANGUAGE = 475,
  LARGE_P = 476,
  LAST_P = 477,
  LATERAL_P = 478,
  LEADING = 479,
  LEAKPROOF = 480,
  LEAST = 481,
  LEFT = 482,
  LEVEL = 483,
  LIKE = 484,
  LIMIT = 485,
  LISTEN = 486,
  LOAD = 487,
  LOCAL = 488,
  LOCALTIME = 489,
  LOCALTIMESTAMP = 490,
  LOCATION = 491,
  LOCK_P = 492,
  LOCKED = 493,
  LOGGED = 494,
  MAPPING = 495,
  MATCH = 496,
  MATERIALIZED = 497,
  MAXVALUE = 498,
  METHOD = 499,
  MINUTE_P = 500,
  MINVALUE = 501,
  MODE = 502,
  MONTH_P = 503,
  MOVE = 504,
  NAME_P = 505,
  NAMES = 506,
  NATIONAL = 507,
  NATURAL = 508,
  NCHAR = 509,
  NEW = 510,
  NEXT = 511,
  NFC = 512,
  NFD = 513,
  NFKC = 514,
  NFKD = 515,
  NO = 516,
  NONE = 517,
  NORMALIZE = 518,
  NORMALIZED = 519,
  NOT = 520,
  NOTHING = 521,
  NOTIFY = 522,
  NOTNULL = 523,
  NOWAIT = 524,
  NULL_P = 525,
  NULLIF = 526,
  NULLS_P = 527,
  NUMERIC = 528,
  OBJECT_P = 529,
  OF = 530,
  OFF = 531,
  OFFSET = 532,
  OIDS = 533,
  OLD = 534,
  ON = 535,
  ONLY = 536,
  OPERATOR = 537,
  OPTION = 538,
  OPTIONS = 539,
  OR = 540,
  ORDER = 541,
  ORDINALITY = 542,
  OTHERS = 543,
  OUT_P = 544,
  OUTER_P = 545,
  OVER = 546,
  OVERLAPS = 547,
  OVERLAY = 548,
  OVERRIDING = 549,
  OWNED = 550,
  OWNER = 551,
  PARALLEL = 552,
  PARSER = 553,
  PARTIAL = 554,
  PARTITION = 555,
  PASSING = 556,
  PASSWORD = 557,
  PLACING = 558,
  PLANS = 559,
  POLICY = 560,
  POSITION = 561,
  PRECEDING = 562,
  PRECISION = 563,
  PRESERVE = 564,
  PREPARE = 565,
  PREPARED = 566,
  PRIMARY = 567,
  PRIOR = 568,
  PRIVILEGES = 569,
  PROCEDURAL = 570,
  PROCEDURE = 571,
  PROCEDURES = 572,
  PROGRAM = 573,
  PUBLICATION = 574,
  QUOTE = 575,
  RANGE = 576,
  READ = 577,
  REAL = 578,
  REASSIGN = 579,
  RECHECK = 580,
  RECURSIVE = 581,
  REF = 582,
  REFERENCES = 583,
  REFERENCING = 584,
  REFRESH = 585,
  REINDEX = 586,
  RELATIVE_P = 587,
  RELEASE = 588,
  RENAME = 589,
  REPEATABLE = 590,
  REPLACE = 591,
  REPLICA = 592,
  RESET = 593,
  RESTART = 594,
  RESTRICT = 595,
  RETURNING = 596,
  RETURNS = 597,
  REVOKE = 598,
  RIGHT = 599,
  ROLE = 600,
  ROLLBACK = 601,
  ROLLUP = 602,
  ROUTINE = 603,
  ROUTINES = 604,
  ROW = 605,
  ROWS = 606,
  RULE = 607,
  SAVEPOINT = 608,
  SCHEMA = 609,
  SCHEMAS = 610,
  SCROLL = 611,
  SEARCH = 612,
  SECOND_P = 613,
  SECURITY = 614,
  SELECT = 615,
  SEQUENCE = 616,
  SEQUENCES = 617,
  SERIALIZABLE = 618,
  SERVER = 619,
  SESSION = 620,
  SESSION_USER = 621,
  SET = 622,
  SETS = 623,
  SETOF = 624,
  SHARE = 625,
  SHOW = 626,
  SIMILAR = 627,
  SIMPLE = 628,
  SKIP = 629,
  SMALLINT = 630,
  SNAPSHOT = 631,
  SOME = 632,
  SQL_P = 633,
  STABLE = 634,
  STANDALONE_P = 635,
  START = 636,
  STATEMENT = 637,
  STATISTICS = 638,
  STDIN = 639,
  STDOUT = 640,
  STORAGE = 641,
  STORED = 642,
  STRICT_P = 643,
  STRIP_P = 644,
  SUBSCRIPTION = 645,
  SUBSTRING = 646,
  SUPPORT = 647,
  SYMMETRIC = 648,
  SYSID = 649,
  SYSTEM_P = 650,
  TABLE = 651,
  TABLES = 652,
  TABLESAMPLE = 653,
  TABLESPACE = 654,
  TEMP = 655,
  TEMPLATE = 656,
  TEMPORARY = 657,
  TEXT_P = 658,
  THEN = 659,
  TIES = 660,
  TIME = 661,
  TIMESTAMP = 662,
  TO = 663,
  TRAILING = 664,
  TRANSACTION = 665,
  TRANSFORM = 666,
  TREAT = 667,
  TRIGGER = 668,
  TRIM = 669,
  TRUE_P = 670,
  TRUNCATE = 671,
  TRUSTED = 672,
  TYPE_P = 673,
  TYPES_P = 674,
  UESCAPE = 675,
  UNBOUNDED = 676,
  UNCOMMITTED = 677,
  UNENCRYPTED = 678,
  UNION = 679,
  UNIQUE = 680,
  UNKNOWN = 681,
  UNLISTEN = 682,
  UNLOGGED = 683,
  UNTIL = 684,
  UPDATE = 685,
  USER = 686,
  USING = 687,
  VACUUM = 688,
  VALID = 689,
  VALIDATE = 690,
  VALIDATOR = 691,
  VALUE_P = 692,
  VALUES = 693,
  VARCHAR = 694,
  VARIADIC = 695,
  VARYING = 696,
  VERBOSE = 697,
  VERSION_P = 698,
  VIEW = 699,
  VIEWS = 700,
  VOLATILE = 701,
  WHEN = 702,
  WHERE = 703,
  WHITESPACE_P = 704,
  WINDOW = 705,
  WITH = 706,
  WITHIN = 707,
  WITHOUT = 708,
  WORK = 709,
  WRAPPER = 710,
  WRITE = 711,
  XML_P = 712,
  XMLATTRIBUTES = 713,
  XMLCONCAT = 714,
  XMLELEMENT = 715,
  XMLEXISTS = 716,
  XMLFOREST = 717,
  XMLNAMESPACES = 718,
  XMLPARSE = 719,
  XMLPI = 720,
  XMLROOT = 721,
  XMLSERIALIZE = 722,
  XMLTABLE = 723,
  YEAR_P = 724,
  YES_P = 725,
  ZONE = 726,
  NOT_LA = 727,
  NULLS_LA = 728,
  WITH_LA = 729,
  POSTFIXOP = 730,
  UMINUS = 731,
  Token_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  Token_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool Token_IsValid(int value);
constexpr Token Token_MIN = NUL;
constexpr Token Token_MAX = UMINUS;
constexpr int Token_ARRAYSIZE = Token_MAX + 1;

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

class ParseResult PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ParseResult) */ {
 public:
  inline ParseResult() : ParseResult(nullptr) {}
  virtual ~ParseResult();

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

  inline ParseResult& operator=(const ParseResult& from) {
    CopyFrom(from);
    return *this;
  }
  inline ParseResult& operator=(ParseResult&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ParseResult& default_instance();

  static inline const ParseResult* internal_default_instance() {
    return reinterpret_cast<const ParseResult*>(
               &_ParseResult_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(ParseResult& a, ParseResult& b) {
    a.Swap(&b);
  }
  inline void Swap(ParseResult* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ParseResult* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ParseResult* New() const final {
    return CreateMaybeMessage<ParseResult>(nullptr);
  }

  ParseResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ParseResult>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ParseResult& from);
  void MergeFrom(const ParseResult& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ParseResult* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ParseResult";
  }
  protected:
  explicit ParseResult(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kStmtsFieldNumber = 2,
    kVersionFieldNumber = 1,
  };
  // repeated .pg_query.RawStmt stmts = 2;
  int stmts_size() const;
  private:
  int _internal_stmts_size() const;
  public:
  void clear_stmts();
  ::pg_query::RawStmt* mutable_stmts(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::RawStmt >*
      mutable_stmts();
  private:
  const ::pg_query::RawStmt& _internal_stmts(int index) const;
  ::pg_query::RawStmt* _internal_add_stmts();
  public:
  const ::pg_query::RawStmt& stmts(int index) const;
  ::pg_query::RawStmt* add_stmts();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::RawStmt >&
      stmts() const;

  // int32 version = 1;
  void clear_version();
  ::PROTOBUF_NAMESPACE_ID::int32 version() const;
  void set_version(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_version() const;
  void _internal_set_version(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ParseResult)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::RawStmt > stmts_;
  ::PROTOBUF_NAMESPACE_ID::int32 version_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ScanResult PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ScanResult) */ {
 public:
  inline ScanResult() : ScanResult(nullptr) {}
  virtual ~ScanResult();

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

  inline ScanResult& operator=(const ScanResult& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScanResult& operator=(ScanResult&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ScanResult& default_instance();

  static inline const ScanResult* internal_default_instance() {
    return reinterpret_cast<const ScanResult*>(
               &_ScanResult_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(ScanResult& a, ScanResult& b) {
    a.Swap(&b);
  }
  inline void Swap(ScanResult* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScanResult* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ScanResult* New() const final {
    return CreateMaybeMessage<ScanResult>(nullptr);
  }

  ScanResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ScanResult>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ScanResult& from);
  void MergeFrom(const ScanResult& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ScanResult* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ScanResult";
  }
  protected:
  explicit ScanResult(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTokensFieldNumber = 2,
    kVersionFieldNumber = 1,
  };
  // repeated .pg_query.ScanToken tokens = 2;
  int tokens_size() const;
  private:
  int _internal_tokens_size() const;
  public:
  void clear_tokens();
  ::pg_query::ScanToken* mutable_tokens(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::ScanToken >*
      mutable_tokens();
  private:
  const ::pg_query::ScanToken& _internal_tokens(int index) const;
  ::pg_query::ScanToken* _internal_add_tokens();
  public:
  const ::pg_query::ScanToken& tokens(int index) const;
  ::pg_query::ScanToken* add_tokens();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::ScanToken >&
      tokens() const;

  // int32 version = 1;
  void clear_version();
  ::PROTOBUF_NAMESPACE_ID::int32 version() const;
  void set_version(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_version() const;
  void _internal_set_version(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ScanResult)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::ScanToken > tokens_;
  ::PROTOBUF_NAMESPACE_ID::int32 version_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class Node PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Node) */ {
 public:
  inline Node() : Node(nullptr) {}
  virtual ~Node();

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

  inline Node& operator=(const Node& from) {
    CopyFrom(from);
    return *this;
  }
  inline Node& operator=(Node&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Node& default_instance();

  enum NodeCase {
    kAlias = 1,
    kRangeVar = 2,
    kTableFunc = 3,
    kExpr = 4,
    kVar = 5,
    kParam = 6,
    kAggref = 7,
    kGroupingFunc = 8,
    kWindowFunc = 9,
    kSubscriptingRef = 10,
    kFuncExpr = 11,
    kNamedArgExpr = 12,
    kOpExpr = 13,
    kDistinctExpr = 14,
    kNullIfExpr = 15,
    kScalarArrayOpExpr = 16,
    kBoolExpr = 17,
    kSubLink = 18,
    kSubPlan = 19,
    kAlternativeSubPlan = 20,
    kFieldSelect = 21,
    kFieldStore = 22,
    kRelabelType = 23,
    kCoerceViaIo = 24,
    kArrayCoerceExpr = 25,
    kConvertRowtypeExpr = 26,
    kCollateExpr = 27,
    kCaseExpr = 28,
    kCaseWhen = 29,
    kCaseTestExpr = 30,
    kArrayExpr = 31,
    kRowExpr = 32,
    kRowCompareExpr = 33,
    kCoalesceExpr = 34,
    kMinMaxExpr = 35,
    kSqlvalueFunction = 36,
    kXmlExpr = 37,
    kNullTest = 38,
    kBooleanTest = 39,
    kCoerceToDomain = 40,
    kCoerceToDomainValue = 41,
    kSetToDefault = 42,
    kCurrentOfExpr = 43,
    kNextValueExpr = 44,
    kInferenceElem = 45,
    kTargetEntry = 46,
    kRangeTblRef = 47,
    kJoinExpr = 48,
    kFromExpr = 49,
    kOnConflictExpr = 50,
    kIntoClause = 51,
    kRawStmt = 52,
    kQuery = 53,
    kInsertStmt = 54,
    kDeleteStmt = 55,
    kUpdateStmt = 56,
    kSelectStmt = 57,
    kAlterTableStmt = 58,
    kAlterTableCmd = 59,
    kAlterDomainStmt = 60,
    kSetOperationStmt = 61,
    kGrantStmt = 62,
    kGrantRoleStmt = 63,
    kAlterDefaultPrivilegesStmt = 64,
    kClosePortalStmt = 65,
    kClusterStmt = 66,
    kCopyStmt = 67,
    kCreateStmt = 68,
    kDefineStmt = 69,
    kDropStmt = 70,
    kTruncateStmt = 71,
    kCommentStmt = 72,
    kFetchStmt = 73,
    kIndexStmt = 74,
    kCreateFunctionStmt = 75,
    kAlterFunctionStmt = 76,
    kDoStmt = 77,
    kRenameStmt = 78,
    kRuleStmt = 79,
    kNotifyStmt = 80,
    kListenStmt = 81,
    kUnlistenStmt = 82,
    kTransactionStmt = 83,
    kViewStmt = 84,
    kLoadStmt = 85,
    kCreateDomainStmt = 86,
    kCreatedbStmt = 87,
    kDropdbStmt = 88,
    kVacuumStmt = 89,
    kExplainStmt = 90,
    kCreateTableAsStmt = 91,
    kCreateSeqStmt = 92,
    kAlterSeqStmt = 93,
    kVariableSetStmt = 94,
    kVariableShowStmt = 95,
    kDiscardStmt = 96,
    kCreateTrigStmt = 97,
    kCreatePlangStmt = 98,
    kCreateRoleStmt = 99,
    kAlterRoleStmt = 100,
    kDropRoleStmt = 101,
    kLockStmt = 102,
    kConstraintsSetStmt = 103,
    kReindexStmt = 104,
    kCheckPointStmt = 105,
    kCreateSchemaStmt = 106,
    kAlterDatabaseStmt = 107,
    kAlterDatabaseSetStmt = 108,
    kAlterRoleSetStmt = 109,
    kCreateConversionStmt = 110,
    kCreateCastStmt = 111,
    kCreateOpClassStmt = 112,
    kCreateOpFamilyStmt = 113,
    kAlterOpFamilyStmt = 114,
    kPrepareStmt = 115,
    kExecuteStmt = 116,
    kDeallocateStmt = 117,
    kDeclareCursorStmt = 118,
    kCreateTableSpaceStmt = 119,
    kDropTableSpaceStmt = 120,
    kAlterObjectDependsStmt = 121,
    kAlterObjectSchemaStmt = 122,
    kAlterOwnerStmt = 123,
    kAlterOperatorStmt = 124,
    kAlterTypeStmt = 125,
    kDropOwnedStmt = 126,
    kReassignOwnedStmt = 127,
    kCompositeTypeStmt = 128,
    kCreateEnumStmt = 129,
    kCreateRangeStmt = 130,
    kAlterEnumStmt = 131,
    kAlterTsdictionaryStmt = 132,
    kAlterTsconfigurationStmt = 133,
    kCreateFdwStmt = 134,
    kAlterFdwStmt = 135,
    kCreateForeignServerStmt = 136,
    kAlterForeignServerStmt = 137,
    kCreateUserMappingStmt = 138,
    kAlterUserMappingStmt = 139,
    kDropUserMappingStmt = 140,
    kAlterTableSpaceOptionsStmt = 141,
    kAlterTableMoveAllStmt = 142,
    kSecLabelStmt = 143,
    kCreateForeignTableStmt = 144,
    kImportForeignSchemaStmt = 145,
    kCreateExtensionStmt = 146,
    kAlterExtensionStmt = 147,
    kAlterExtensionContentsStmt = 148,
    kCreateEventTrigStmt = 149,
    kAlterEventTrigStmt = 150,
    kRefreshMatViewStmt = 151,
    kReplicaIdentityStmt = 152,
    kAlterSystemStmt = 153,
    kCreatePolicyStmt = 154,
    kAlterPolicyStmt = 155,
    kCreateTransformStmt = 156,
    kCreateAmStmt = 157,
    kCreatePublicationStmt = 158,
    kAlterPublicationStmt = 159,
    kCreateSubscriptionStmt = 160,
    kAlterSubscriptionStmt = 161,
    kDropSubscriptionStmt = 162,
    kCreateStatsStmt = 163,
    kAlterCollationStmt = 164,
    kCallStmt = 165,
    kAlterStatsStmt = 166,
    kAExpr = 167,
    kColumnRef = 168,
    kParamRef = 169,
    kAConst = 170,
    kFuncCall = 171,
    kAStar = 172,
    kAIndices = 173,
    kAIndirection = 174,
    kAArrayExpr = 175,
    kResTarget = 176,
    kMultiAssignRef = 177,
    kTypeCast = 178,
    kCollateClause = 179,
    kSortBy = 180,
    kWindowDef = 181,
    kRangeSubselect = 182,
    kRangeFunction = 183,
    kRangeTableSample = 184,
    kRangeTableFunc = 185,
    kRangeTableFuncCol = 186,
    kTypeName = 187,
    kColumnDef = 188,
    kIndexElem = 189,
    kConstraint = 190,
    kDefElem = 191,
    kRangeTblEntry = 192,
    kRangeTblFunction = 193,
    kTableSampleClause = 194,
    kWithCheckOption = 195,
    kSortGroupClause = 196,
    kGroupingSet = 197,
    kWindowClause = 198,
    kObjectWithArgs = 199,
    kAccessPriv = 200,
    kCreateOpClassItem = 201,
    kTableLikeClause = 202,
    kFunctionParameter = 203,
    kLockingClause = 204,
    kRowMarkClause = 205,
    kXmlSerialize = 206,
    kWithClause = 207,
    kInferClause = 208,
    kOnConflictClause = 209,
    kCommonTableExpr = 210,
    kRoleSpec = 211,
    kTriggerTransition = 212,
    kPartitionElem = 213,
    kPartitionSpec = 214,
    kPartitionBoundSpec = 215,
    kPartitionRangeDatum = 216,
    kPartitionCmd = 217,
    kVacuumRelation = 218,
    kInlineCodeBlock = 219,
    kCallContext = 220,
    kInteger = 221,
    kFloat = 222,
    kString = 223,
    kBitString = 224,
    kNull = 225,
    kList = 226,
    kIntList = 227,
    kOidList = 228,
    NODE_NOT_SET = 0,
  };

  static inline const Node* internal_default_instance() {
    return reinterpret_cast<const Node*>(
               &_Node_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(Node& a, Node& b) {
    a.Swap(&b);
  }
  inline void Swap(Node* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Node* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Node* New() const final {
    return CreateMaybeMessage<Node>(nullptr);
  }

  Node* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Node>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Node& from);
  void MergeFrom(const Node& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Node* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.Node";
  }
  protected:
  explicit Node(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAliasFieldNumber = 1,
    kRangeVarFieldNumber = 2,
    kTableFuncFieldNumber = 3,
    kExprFieldNumber = 4,
    kVarFieldNumber = 5,
    kParamFieldNumber = 6,
    kAggrefFieldNumber = 7,
    kGroupingFuncFieldNumber = 8,
    kWindowFuncFieldNumber = 9,
    kSubscriptingRefFieldNumber = 10,
    kFuncExprFieldNumber = 11,
    kNamedArgExprFieldNumber = 12,
    kOpExprFieldNumber = 13,
    kDistinctExprFieldNumber = 14,
    kNullIfExprFieldNumber = 15,
    kScalarArrayOpExprFieldNumber = 16,
    kBoolExprFieldNumber = 17,
    kSubLinkFieldNumber = 18,
    kSubPlanFieldNumber = 19,
    kAlternativeSubPlanFieldNumber = 20,
    kFieldSelectFieldNumber = 21,
    kFieldStoreFieldNumber = 22,
    kRelabelTypeFieldNumber = 23,
    kCoerceViaIoFieldNumber = 24,
    kArrayCoerceExprFieldNumber = 25,
    kConvertRowtypeExprFieldNumber = 26,
    kCollateExprFieldNumber = 27,
    kCaseExprFieldNumber = 28,
    kCaseWhenFieldNumber = 29,
    kCaseTestExprFieldNumber = 30,
    kArrayExprFieldNumber = 31,
    kRowExprFieldNumber = 32,
    kRowCompareExprFieldNumber = 33,
    kCoalesceExprFieldNumber = 34,
    kMinMaxExprFieldNumber = 35,
    kSqlvalueFunctionFieldNumber = 36,
    kXmlExprFieldNumber = 37,
    kNullTestFieldNumber = 38,
    kBooleanTestFieldNumber = 39,
    kCoerceToDomainFieldNumber = 40,
    kCoerceToDomainValueFieldNumber = 41,
    kSetToDefaultFieldNumber = 42,
    kCurrentOfExprFieldNumber = 43,
    kNextValueExprFieldNumber = 44,
    kInferenceElemFieldNumber = 45,
    kTargetEntryFieldNumber = 46,
    kRangeTblRefFieldNumber = 47,
    kJoinExprFieldNumber = 48,
    kFromExprFieldNumber = 49,
    kOnConflictExprFieldNumber = 50,
    kIntoClauseFieldNumber = 51,
    kRawStmtFieldNumber = 52,
    kQueryFieldNumber = 53,
    kInsertStmtFieldNumber = 54,
    kDeleteStmtFieldNumber = 55,
    kUpdateStmtFieldNumber = 56,
    kSelectStmtFieldNumber = 57,
    kAlterTableStmtFieldNumber = 58,
    kAlterTableCmdFieldNumber = 59,
    kAlterDomainStmtFieldNumber = 60,
    kSetOperationStmtFieldNumber = 61,
    kGrantStmtFieldNumber = 62,
    kGrantRoleStmtFieldNumber = 63,
    kAlterDefaultPrivilegesStmtFieldNumber = 64,
    kClosePortalStmtFieldNumber = 65,
    kClusterStmtFieldNumber = 66,
    kCopyStmtFieldNumber = 67,
    kCreateStmtFieldNumber = 68,
    kDefineStmtFieldNumber = 69,
    kDropStmtFieldNumber = 70,
    kTruncateStmtFieldNumber = 71,
    kCommentStmtFieldNumber = 72,
    kFetchStmtFieldNumber = 73,
    kIndexStmtFieldNumber = 74,
    kCreateFunctionStmtFieldNumber = 75,
    kAlterFunctionStmtFieldNumber = 76,
    kDoStmtFieldNumber = 77,
    kRenameStmtFieldNumber = 78,
    kRuleStmtFieldNumber = 79,
    kNotifyStmtFieldNumber = 80,
    kListenStmtFieldNumber = 81,
    kUnlistenStmtFieldNumber = 82,
    kTransactionStmtFieldNumber = 83,
    kViewStmtFieldNumber = 84,
    kLoadStmtFieldNumber = 85,
    kCreateDomainStmtFieldNumber = 86,
    kCreatedbStmtFieldNumber = 87,
    kDropdbStmtFieldNumber = 88,
    kVacuumStmtFieldNumber = 89,
    kExplainStmtFieldNumber = 90,
    kCreateTableAsStmtFieldNumber = 91,
    kCreateSeqStmtFieldNumber = 92,
    kAlterSeqStmtFieldNumber = 93,
    kVariableSetStmtFieldNumber = 94,
    kVariableShowStmtFieldNumber = 95,
    kDiscardStmtFieldNumber = 96,
    kCreateTrigStmtFieldNumber = 97,
    kCreatePlangStmtFieldNumber = 98,
    kCreateRoleStmtFieldNumber = 99,
    kAlterRoleStmtFieldNumber = 100,
    kDropRoleStmtFieldNumber = 101,
    kLockStmtFieldNumber = 102,
    kConstraintsSetStmtFieldNumber = 103,
    kReindexStmtFieldNumber = 104,
    kCheckPointStmtFieldNumber = 105,
    kCreateSchemaStmtFieldNumber = 106,
    kAlterDatabaseStmtFieldNumber = 107,
    kAlterDatabaseSetStmtFieldNumber = 108,
    kAlterRoleSetStmtFieldNumber = 109,
    kCreateConversionStmtFieldNumber = 110,
    kCreateCastStmtFieldNumber = 111,
    kCreateOpClassStmtFieldNumber = 112,
    kCreateOpFamilyStmtFieldNumber = 113,
    kAlterOpFamilyStmtFieldNumber = 114,
    kPrepareStmtFieldNumber = 115,
    kExecuteStmtFieldNumber = 116,
    kDeallocateStmtFieldNumber = 117,
    kDeclareCursorStmtFieldNumber = 118,
    kCreateTableSpaceStmtFieldNumber = 119,
    kDropTableSpaceStmtFieldNumber = 120,
    kAlterObjectDependsStmtFieldNumber = 121,
    kAlterObjectSchemaStmtFieldNumber = 122,
    kAlterOwnerStmtFieldNumber = 123,
    kAlterOperatorStmtFieldNumber = 124,
    kAlterTypeStmtFieldNumber = 125,
    kDropOwnedStmtFieldNumber = 126,
    kReassignOwnedStmtFieldNumber = 127,
    kCompositeTypeStmtFieldNumber = 128,
    kCreateEnumStmtFieldNumber = 129,
    kCreateRangeStmtFieldNumber = 130,
    kAlterEnumStmtFieldNumber = 131,
    kAlterTsdictionaryStmtFieldNumber = 132,
    kAlterTsconfigurationStmtFieldNumber = 133,
    kCreateFdwStmtFieldNumber = 134,
    kAlterFdwStmtFieldNumber = 135,
    kCreateForeignServerStmtFieldNumber = 136,
    kAlterForeignServerStmtFieldNumber = 137,
    kCreateUserMappingStmtFieldNumber = 138,
    kAlterUserMappingStmtFieldNumber = 139,
    kDropUserMappingStmtFieldNumber = 140,
    kAlterTableSpaceOptionsStmtFieldNumber = 141,
    kAlterTableMoveAllStmtFieldNumber = 142,
    kSecLabelStmtFieldNumber = 143,
    kCreateForeignTableStmtFieldNumber = 144,
    kImportForeignSchemaStmtFieldNumber = 145,
    kCreateExtensionStmtFieldNumber = 146,
    kAlterExtensionStmtFieldNumber = 147,
    kAlterExtensionContentsStmtFieldNumber = 148,
    kCreateEventTrigStmtFieldNumber = 149,
    kAlterEventTrigStmtFieldNumber = 150,
    kRefreshMatViewStmtFieldNumber = 151,
    kReplicaIdentityStmtFieldNumber = 152,
    kAlterSystemStmtFieldNumber = 153,
    kCreatePolicyStmtFieldNumber = 154,
    kAlterPolicyStmtFieldNumber = 155,
    kCreateTransformStmtFieldNumber = 156,
    kCreateAmStmtFieldNumber = 157,
    kCreatePublicationStmtFieldNumber = 158,
    kAlterPublicationStmtFieldNumber = 159,
    kCreateSubscriptionStmtFieldNumber = 160,
    kAlterSubscriptionStmtFieldNumber = 161,
    kDropSubscriptionStmtFieldNumber = 162,
    kCreateStatsStmtFieldNumber = 163,
    kAlterCollationStmtFieldNumber = 164,
    kCallStmtFieldNumber = 165,
    kAlterStatsStmtFieldNumber = 166,
    kAExprFieldNumber = 167,
    kColumnRefFieldNumber = 168,
    kParamRefFieldNumber = 169,
    kAConstFieldNumber = 170,
    kFuncCallFieldNumber = 171,
    kAStarFieldNumber = 172,
    kAIndicesFieldNumber = 173,
    kAIndirectionFieldNumber = 174,
    kAArrayExprFieldNumber = 175,
    kResTargetFieldNumber = 176,
    kMultiAssignRefFieldNumber = 177,
    kTypeCastFieldNumber = 178,
    kCollateClauseFieldNumber = 179,
    kSortByFieldNumber = 180,
    kWindowDefFieldNumber = 181,
    kRangeSubselectFieldNumber = 182,
    kRangeFunctionFieldNumber = 183,
    kRangeTableSampleFieldNumber = 184,
    kRangeTableFuncFieldNumber = 185,
    kRangeTableFuncColFieldNumber = 186,
    kTypeNameFieldNumber = 187,
    kColumnDefFieldNumber = 188,
    kIndexElemFieldNumber = 189,
    kConstraintFieldNumber = 190,
    kDefElemFieldNumber = 191,
    kRangeTblEntryFieldNumber = 192,
    kRangeTblFunctionFieldNumber = 193,
    kTableSampleClauseFieldNumber = 194,
    kWithCheckOptionFieldNumber = 195,
    kSortGroupClauseFieldNumber = 196,
    kGroupingSetFieldNumber = 197,
    kWindowClauseFieldNumber = 198,
    kObjectWithArgsFieldNumber = 199,
    kAccessPrivFieldNumber = 200,
    kCreateOpClassItemFieldNumber = 201,
    kTableLikeClauseFieldNumber = 202,
    kFunctionParameterFieldNumber = 203,
    kLockingClauseFieldNumber = 204,
    kRowMarkClauseFieldNumber = 205,
    kXmlSerializeFieldNumber = 206,
    kWithClauseFieldNumber = 207,
    kInferClauseFieldNumber = 208,
    kOnConflictClauseFieldNumber = 209,
    kCommonTableExprFieldNumber = 210,
    kRoleSpecFieldNumber = 211,
    kTriggerTransitionFieldNumber = 212,
    kPartitionElemFieldNumber = 213,
    kPartitionSpecFieldNumber = 214,
    kPartitionBoundSpecFieldNumber = 215,
    kPartitionRangeDatumFieldNumber = 216,
    kPartitionCmdFieldNumber = 217,
    kVacuumRelationFieldNumber = 218,
    kInlineCodeBlockFieldNumber = 219,
    kCallContextFieldNumber = 220,
    kIntegerFieldNumber = 221,
    kFloatFieldNumber = 222,
    kStringFieldNumber = 223,
    kBitStringFieldNumber = 224,
    kNullFieldNumber = 225,
    kListFieldNumber = 226,
    kIntListFieldNumber = 227,
    kOidListFieldNumber = 228,
  };
  // .pg_query.Alias alias = 1 [json_name = "Alias"];
  bool has_alias() const;
  private:
  bool _internal_has_alias() const;
  public:
  void clear_alias();
  const ::pg_query::Alias& alias() const;
  ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* alias);
  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();
  public:
  void unsafe_arena_set_allocated_alias(
      ::pg_query::Alias* alias);
  ::pg_query::Alias* unsafe_arena_release_alias();

  // .pg_query.RangeVar range_var = 2 [json_name = "RangeVar"];
  bool has_range_var() const;
  private:
  bool _internal_has_range_var() const;
  public:
  void clear_range_var();
  const ::pg_query::RangeVar& range_var() const;
  ::pg_query::RangeVar* release_range_var();
  ::pg_query::RangeVar* mutable_range_var();
  void set_allocated_range_var(::pg_query::RangeVar* range_var);
  private:
  const ::pg_query::RangeVar& _internal_range_var() const;
  ::pg_query::RangeVar* _internal_mutable_range_var();
  public:
  void unsafe_arena_set_allocated_range_var(
      ::pg_query::RangeVar* range_var);
  ::pg_query::RangeVar* unsafe_arena_release_range_var();

  // .pg_query.TableFunc table_func = 3 [json_name = "TableFunc"];
  bool has_table_func() const;
  private:
  bool _internal_has_table_func() const;
  public:
  void clear_table_func();
  const ::pg_query::TableFunc& table_func() const;
  ::pg_query::TableFunc* release_table_func();
  ::pg_query::TableFunc* mutable_table_func();
  void set_allocated_table_func(::pg_query::TableFunc* table_func);
  private:
  const ::pg_query::TableFunc& _internal_table_func() const;
  ::pg_query::TableFunc* _internal_mutable_table_func();
  public:
  void unsafe_arena_set_allocated_table_func(
      ::pg_query::TableFunc* table_func);
  ::pg_query::TableFunc* unsafe_arena_release_table_func();

  // .pg_query.Expr expr = 4 [json_name = "Expr"];
  bool has_expr() const;
  private:
  bool _internal_has_expr() const;
  public:
  void clear_expr();
  const ::pg_query::Expr& expr() const;
  ::pg_query::Expr* release_expr();
  ::pg_query::Expr* mutable_expr();
  void set_allocated_expr(::pg_query::Expr* expr);
  private:
  const ::pg_query::Expr& _internal_expr() const;
  ::pg_query::Expr* _internal_mutable_expr();
  public:
  void unsafe_arena_set_allocated_expr(
      ::pg_query::Expr* expr);
  ::pg_query::Expr* unsafe_arena_release_expr();

  // .pg_query.Var var = 5 [json_name = "Var"];
  bool has_var() const;
  private:
  bool _internal_has_var() const;
  public:
  void clear_var();
  const ::pg_query::Var& var() const;
  ::pg_query::Var* release_var();
  ::pg_query::Var* mutable_var();
  void set_allocated_var(::pg_query::Var* var);
  private:
  const ::pg_query::Var& _internal_var() const;
  ::pg_query::Var* _internal_mutable_var();
  public:
  void unsafe_arena_set_allocated_var(
      ::pg_query::Var* var);
  ::pg_query::Var* unsafe_arena_release_var();

  // .pg_query.Param param = 6 [json_name = "Param"];
  bool has_param() const;
  private:
  bool _internal_has_param() const;
  public:
  void clear_param();
  const ::pg_query::Param& param() const;
  ::pg_query::Param* release_param();
  ::pg_query::Param* mutable_param();
  void set_allocated_param(::pg_query::Param* param);
  private:
  const ::pg_query::Param& _internal_param() const;
  ::pg_query::Param* _internal_mutable_param();
  public:
  void unsafe_arena_set_allocated_param(
      ::pg_query::Param* param);
  ::pg_query::Param* unsafe_arena_release_param();

  // .pg_query.Aggref aggref = 7 [json_name = "Aggref"];
  bool has_aggref() const;
  private:
  bool _internal_has_aggref() const;
  public:
  void clear_aggref();
  const ::pg_query::Aggref& aggref() const;
  ::pg_query::Aggref* release_aggref();
  ::pg_query::Aggref* mutable_aggref();
  void set_allocated_aggref(::pg_query::Aggref* aggref);
  private:
  const ::pg_query::Aggref& _internal_aggref() const;
  ::pg_query::Aggref* _internal_mutable_aggref();
  public:
  void unsafe_arena_set_allocated_aggref(
      ::pg_query::Aggref* aggref);
  ::pg_query::Aggref* unsafe_arena_release_aggref();

  // .pg_query.GroupingFunc grouping_func = 8 [json_name = "GroupingFunc"];
  bool has_grouping_func() const;
  private:
  bool _internal_has_grouping_func() const;
  public:
  void clear_grouping_func();
  const ::pg_query::GroupingFunc& grouping_func() const;
  ::pg_query::GroupingFunc* release_grouping_func();
  ::pg_query::GroupingFunc* mutable_grouping_func();
  void set_allocated_grouping_func(::pg_query::GroupingFunc* grouping_func);
  private:
  const ::pg_query::GroupingFunc& _internal_grouping_func() const;
  ::pg_query::GroupingFunc* _internal_mutable_grouping_func();
  public:
  void unsafe_arena_set_allocated_grouping_func(
      ::pg_query::GroupingFunc* grouping_func);
  ::pg_query::GroupingFunc* unsafe_arena_release_grouping_func();

  // .pg_query.WindowFunc window_func = 9 [json_name = "WindowFunc"];
  bool has_window_func() const;
  private:
  bool _internal_has_window_func() const;
  public:
  void clear_window_func();
  const ::pg_query::WindowFunc& window_func() const;
  ::pg_query::WindowFunc* release_window_func();
  ::pg_query::WindowFunc* mutable_window_func();
  void set_allocated_window_func(::pg_query::WindowFunc* window_func);
  private:
  const ::pg_query::WindowFunc& _internal_window_func() const;
  ::pg_query::WindowFunc* _internal_mutable_window_func();
  public:
  void unsafe_arena_set_allocated_window_func(
      ::pg_query::WindowFunc* window_func);
  ::pg_query::WindowFunc* unsafe_arena_release_window_func();

  // .pg_query.SubscriptingRef subscripting_ref = 10 [json_name = "SubscriptingRef"];
  bool has_subscripting_ref() const;
  private:
  bool _internal_has_subscripting_ref() const;
  public:
  void clear_subscripting_ref();
  const ::pg_query::SubscriptingRef& subscripting_ref() const;
  ::pg_query::SubscriptingRef* release_subscripting_ref();
  ::pg_query::SubscriptingRef* mutable_subscripting_ref();
  void set_allocated_subscripting_ref(::pg_query::SubscriptingRef* subscripting_ref);
  private:
  const ::pg_query::SubscriptingRef& _internal_subscripting_ref() const;
  ::pg_query::SubscriptingRef* _internal_mutable_subscripting_ref();
  public:
  void unsafe_arena_set_allocated_subscripting_ref(
      ::pg_query::SubscriptingRef* subscripting_ref);
  ::pg_query::SubscriptingRef* unsafe_arena_release_subscripting_ref();

  // .pg_query.FuncExpr func_expr = 11 [json_name = "FuncExpr"];
  bool has_func_expr() const;
  private:
  bool _internal_has_func_expr() const;
  public:
  void clear_func_expr();
  const ::pg_query::FuncExpr& func_expr() const;
  ::pg_query::FuncExpr* release_func_expr();
  ::pg_query::FuncExpr* mutable_func_expr();
  void set_allocated_func_expr(::pg_query::FuncExpr* func_expr);
  private:
  const ::pg_query::FuncExpr& _internal_func_expr() const;
  ::pg_query::FuncExpr* _internal_mutable_func_expr();
  public:
  void unsafe_arena_set_allocated_func_expr(
      ::pg_query::FuncExpr* func_expr);
  ::pg_query::FuncExpr* unsafe_arena_release_func_expr();

  // .pg_query.NamedArgExpr named_arg_expr = 12 [json_name = "NamedArgExpr"];
  bool has_named_arg_expr() const;
  private:
  bool _internal_has_named_arg_expr() const;
  public:
  void clear_named_arg_expr();
  const ::pg_query::NamedArgExpr& named_arg_expr() const;
  ::pg_query::NamedArgExpr* release_named_arg_expr();
  ::pg_query::NamedArgExpr* mutable_named_arg_expr();
  void set_allocated_named_arg_expr(::pg_query::NamedArgExpr* named_arg_expr);
  private:
  const ::pg_query::NamedArgExpr& _internal_named_arg_expr() const;
  ::pg_query::NamedArgExpr* _internal_mutable_named_arg_expr();
  public:
  void unsafe_arena_set_allocated_named_arg_expr(
      ::pg_query::NamedArgExpr* named_arg_expr);
  ::pg_query::NamedArgExpr* unsafe_arena_release_named_arg_expr();

  // .pg_query.OpExpr op_expr = 13 [json_name = "OpExpr"];
  bool has_op_expr() const;
  private:
  bool _internal_has_op_expr() const;
  public:
  void clear_op_expr();
  const ::pg_query::OpExpr& op_expr() const;
  ::pg_query::OpExpr* release_op_expr();
  ::pg_query::OpExpr* mutable_op_expr();
  void set_allocated_op_expr(::pg_query::OpExpr* op_expr);
  private:
  const ::pg_query::OpExpr& _internal_op_expr() const;
  ::pg_query::OpExpr* _internal_mutable_op_expr();
  public:
  void unsafe_arena_set_allocated_op_expr(
      ::pg_query::OpExpr* op_expr);
  ::pg_query::OpExpr* unsafe_arena_release_op_expr();

  // .pg_query.DistinctExpr distinct_expr = 14 [json_name = "DistinctExpr"];
  bool has_distinct_expr() const;
  private:
  bool _internal_has_distinct_expr() const;
  public:
  void clear_distinct_expr();
  const ::pg_query::DistinctExpr& distinct_expr() const;
  ::pg_query::DistinctExpr* release_distinct_expr();
  ::pg_query::DistinctExpr* mutable_distinct_expr();
  void set_allocated_distinct_expr(::pg_query::DistinctExpr* distinct_expr);
  private:
  const ::pg_query::DistinctExpr& _internal_distinct_expr() const;
  ::pg_query::DistinctExpr* _internal_mutable_distinct_expr();
  public:
  void unsafe_arena_set_allocated_distinct_expr(
      ::pg_query::DistinctExpr* distinct_expr);
  ::pg_query::DistinctExpr* unsafe_arena_release_distinct_expr();

  // .pg_query.NullIfExpr null_if_expr = 15 [json_name = "NullIfExpr"];
  bool has_null_if_expr() const;
  private:
  bool _internal_has_null_if_expr() const;
  public:
  void clear_null_if_expr();
  const ::pg_query::NullIfExpr& null_if_expr() const;
  ::pg_query::NullIfExpr* release_null_if_expr();
  ::pg_query::NullIfExpr* mutable_null_if_expr();
  void set_allocated_null_if_expr(::pg_query::NullIfExpr* null_if_expr);
  private:
  const ::pg_query::NullIfExpr& _internal_null_if_expr() const;
  ::pg_query::NullIfExpr* _internal_mutable_null_if_expr();
  public:
  void unsafe_arena_set_allocated_null_if_expr(
      ::pg_query::NullIfExpr* null_if_expr);
  ::pg_query::NullIfExpr* unsafe_arena_release_null_if_expr();

  // .pg_query.ScalarArrayOpExpr scalar_array_op_expr = 16 [json_name = "ScalarArrayOpExpr"];
  bool has_scalar_array_op_expr() const;
  private:
  bool _internal_has_scalar_array_op_expr() const;
  public:
  void clear_scalar_array_op_expr();
  const ::pg_query::ScalarArrayOpExpr& scalar_array_op_expr() const;
  ::pg_query::ScalarArrayOpExpr* release_scalar_array_op_expr();
  ::pg_query::ScalarArrayOpExpr* mutable_scalar_array_op_expr();
  void set_allocated_scalar_array_op_expr(::pg_query::ScalarArrayOpExpr* scalar_array_op_expr);
  private:
  const ::pg_query::ScalarArrayOpExpr& _internal_scalar_array_op_expr() const;
  ::pg_query::ScalarArrayOpExpr* _internal_mutable_scalar_array_op_expr();
  public:
  void unsafe_arena_set_allocated_scalar_array_op_expr(
      ::pg_query::ScalarArrayOpExpr* scalar_array_op_expr);
  ::pg_query::ScalarArrayOpExpr* unsafe_arena_release_scalar_array_op_expr();

  // .pg_query.BoolExpr bool_expr = 17 [json_name = "BoolExpr"];
  bool has_bool_expr() const;
  private:
  bool _internal_has_bool_expr() const;
  public:
  void clear_bool_expr();
  const ::pg_query::BoolExpr& bool_expr() const;
  ::pg_query::BoolExpr* release_bool_expr();
  ::pg_query::BoolExpr* mutable_bool_expr();
  void set_allocated_bool_expr(::pg_query::BoolExpr* bool_expr);
  private:
  const ::pg_query::BoolExpr& _internal_bool_expr() const;
  ::pg_query::BoolExpr* _internal_mutable_bool_expr();
  public:
  void unsafe_arena_set_allocated_bool_expr(
      ::pg_query::BoolExpr* bool_expr);
  ::pg_query::BoolExpr* unsafe_arena_release_bool_expr();

  // .pg_query.SubLink sub_link = 18 [json_name = "SubLink"];
  bool has_sub_link() const;
  private:
  bool _internal_has_sub_link() const;
  public:
  void clear_sub_link();
  const ::pg_query::SubLink& sub_link() const;
  ::pg_query::SubLink* release_sub_link();
  ::pg_query::SubLink* mutable_sub_link();
  void set_allocated_sub_link(::pg_query::SubLink* sub_link);
  private:
  const ::pg_query::SubLink& _internal_sub_link() const;
  ::pg_query::SubLink* _internal_mutable_sub_link();
  public:
  void unsafe_arena_set_allocated_sub_link(
      ::pg_query::SubLink* sub_link);
  ::pg_query::SubLink* unsafe_arena_release_sub_link();

  // .pg_query.SubPlan sub_plan = 19 [json_name = "SubPlan"];
  bool has_sub_plan() const;
  private:
  bool _internal_has_sub_plan() const;
  public:
  void clear_sub_plan();
  const ::pg_query::SubPlan& sub_plan() const;
  ::pg_query::SubPlan* release_sub_plan();
  ::pg_query::SubPlan* mutable_sub_plan();
  void set_allocated_sub_plan(::pg_query::SubPlan* sub_plan);
  private:
  const ::pg_query::SubPlan& _internal_sub_plan() const;
  ::pg_query::SubPlan* _internal_mutable_sub_plan();
  public:
  void unsafe_arena_set_allocated_sub_plan(
      ::pg_query::SubPlan* sub_plan);
  ::pg_query::SubPlan* unsafe_arena_release_sub_plan();

  // .pg_query.AlternativeSubPlan alternative_sub_plan = 20 [json_name = "AlternativeSubPlan"];
  bool has_alternative_sub_plan() const;
  private:
  bool _internal_has_alternative_sub_plan() const;
  public:
  void clear_alternative_sub_plan();
  const ::pg_query::AlternativeSubPlan& alternative_sub_plan() const;
  ::pg_query::AlternativeSubPlan* release_alternative_sub_plan();
  ::pg_query::AlternativeSubPlan* mutable_alternative_sub_plan();
  void set_allocated_alternative_sub_plan(::pg_query::AlternativeSubPlan* alternative_sub_plan);
  private:
  const ::pg_query::AlternativeSubPlan& _internal_alternative_sub_plan() const;
  ::pg_query::AlternativeSubPlan* _internal_mutable_alternative_sub_plan();
  public:
  void unsafe_arena_set_allocated_alternative_sub_plan(
      ::pg_query::AlternativeSubPlan* alternative_sub_plan);
  ::pg_query::AlternativeSubPlan* unsafe_arena_release_alternative_sub_plan();

  // .pg_query.FieldSelect field_select = 21 [json_name = "FieldSelect"];
  bool has_field_select() const;
  private:
  bool _internal_has_field_select() const;
  public:
  void clear_field_select();
  const ::pg_query::FieldSelect& field_select() const;
  ::pg_query::FieldSelect* release_field_select();
  ::pg_query::FieldSelect* mutable_field_select();
  void set_allocated_field_select(::pg_query::FieldSelect* field_select);
  private:
  const ::pg_query::FieldSelect& _internal_field_select() const;
  ::pg_query::FieldSelect* _internal_mutable_field_select();
  public:
  void unsafe_arena_set_allocated_field_select(
      ::pg_query::FieldSelect* field_select);
  ::pg_query::FieldSelect* unsafe_arena_release_field_select();

  // .pg_query.FieldStore field_store = 22 [json_name = "FieldStore"];
  bool has_field_store() const;
  private:
  bool _internal_has_field_store() const;
  public:
  void clear_field_store();
  const ::pg_query::FieldStore& field_store() const;
  ::pg_query::FieldStore* release_field_store();
  ::pg_query::FieldStore* mutable_field_store();
  void set_allocated_field_store(::pg_query::FieldStore* field_store);
  private:
  const ::pg_query::FieldStore& _internal_field_store() const;
  ::pg_query::FieldStore* _internal_mutable_field_store();
  public:
  void unsafe_arena_set_allocated_field_store(
      ::pg_query::FieldStore* field_store);
  ::pg_query::FieldStore* unsafe_arena_release_field_store();

  // .pg_query.RelabelType relabel_type = 23 [json_name = "RelabelType"];
  bool has_relabel_type() const;
  private:
  bool _internal_has_relabel_type() const;
  public:
  void clear_relabel_type();
  const ::pg_query::RelabelType& relabel_type() const;
  ::pg_query::RelabelType* release_relabel_type();
  ::pg_query::RelabelType* mutable_relabel_type();
  void set_allocated_relabel_type(::pg_query::RelabelType* relabel_type);
  private:
  const ::pg_query::RelabelType& _internal_relabel_type() const;
  ::pg_query::RelabelType* _internal_mutable_relabel_type();
  public:
  void unsafe_arena_set_allocated_relabel_type(
      ::pg_query::RelabelType* relabel_type);
  ::pg_query::RelabelType* unsafe_arena_release_relabel_type();

  // .pg_query.CoerceViaIO coerce_via_io = 24 [json_name = "CoerceViaIO"];
  bool has_coerce_via_io() const;
  private:
  bool _internal_has_coerce_via_io() const;
  public:
  void clear_coerce_via_io();
  const ::pg_query::CoerceViaIO& coerce_via_io() const;
  ::pg_query::CoerceViaIO* release_coerce_via_io();
  ::pg_query::CoerceViaIO* mutable_coerce_via_io();
  void set_allocated_coerce_via_io(::pg_query::CoerceViaIO* coerce_via_io);
  private:
  const ::pg_query::CoerceViaIO& _internal_coerce_via_io() const;
  ::pg_query::CoerceViaIO* _internal_mutable_coerce_via_io();
  public:
  void unsafe_arena_set_allocated_coerce_via_io(
      ::pg_query::CoerceViaIO* coerce_via_io);
  ::pg_query::CoerceViaIO* unsafe_arena_release_coerce_via_io();

  // .pg_query.ArrayCoerceExpr array_coerce_expr = 25 [json_name = "ArrayCoerceExpr"];
  bool has_array_coerce_expr() const;
  private:
  bool _internal_has_array_coerce_expr() const;
  public:
  void clear_array_coerce_expr();
  const ::pg_query::ArrayCoerceExpr& array_coerce_expr() const;
  ::pg_query::ArrayCoerceExpr* release_array_coerce_expr();
  ::pg_query::ArrayCoerceExpr* mutable_array_coerce_expr();
  void set_allocated_array_coerce_expr(::pg_query::ArrayCoerceExpr* array_coerce_expr);
  private:
  const ::pg_query::ArrayCoerceExpr& _internal_array_coerce_expr() const;
  ::pg_query::ArrayCoerceExpr* _internal_mutable_array_coerce_expr();
  public:
  void unsafe_arena_set_allocated_array_coerce_expr(
      ::pg_query::ArrayCoerceExpr* array_coerce_expr);
  ::pg_query::ArrayCoerceExpr* unsafe_arena_release_array_coerce_expr();

  // .pg_query.ConvertRowtypeExpr convert_rowtype_expr = 26 [json_name = "ConvertRowtypeExpr"];
  bool has_convert_rowtype_expr() const;
  private:
  bool _internal_has_convert_rowtype_expr() const;
  public:
  void clear_convert_rowtype_expr();
  const ::pg_query::ConvertRowtypeExpr& convert_rowtype_expr() const;
  ::pg_query::ConvertRowtypeExpr* release_convert_rowtype_expr();
  ::pg_query::ConvertRowtypeExpr* mutable_convert_rowtype_expr();
  void set_allocated_convert_rowtype_expr(::pg_query::ConvertRowtypeExpr* convert_rowtype_expr);
  private:
  const ::pg_query::ConvertRowtypeExpr& _internal_convert_rowtype_expr() const;
  ::pg_query::ConvertRowtypeExpr* _internal_mutable_convert_rowtype_expr();
  public:
  void unsafe_arena_set_allocated_convert_rowtype_expr(
      ::pg_query::ConvertRowtypeExpr* convert_rowtype_expr);
  ::pg_query::ConvertRowtypeExpr* unsafe_arena_release_convert_rowtype_expr();

  // .pg_query.CollateExpr collate_expr = 27 [json_name = "CollateExpr"];
  bool has_collate_expr() const;
  private:
  bool _internal_has_collate_expr() const;
  public:
  void clear_collate_expr();
  const ::pg_query::CollateExpr& collate_expr() const;
  ::pg_query::CollateExpr* release_collate_expr();
  ::pg_query::CollateExpr* mutable_collate_expr();
  void set_allocated_collate_expr(::pg_query::CollateExpr* collate_expr);
  private:
  const ::pg_query::CollateExpr& _internal_collate_expr() const;
  ::pg_query::CollateExpr* _internal_mutable_collate_expr();
  public:
  void unsafe_arena_set_allocated_collate_expr(
      ::pg_query::CollateExpr* collate_expr);
  ::pg_query::CollateExpr* unsafe_arena_release_collate_expr();

  // .pg_query.CaseExpr case_expr = 28 [json_name = "CaseExpr"];
  bool has_case_expr() const;
  private:
  bool _internal_has_case_expr() const;
  public:
  void clear_case_expr();
  const ::pg_query::CaseExpr& case_expr() const;
  ::pg_query::CaseExpr* release_case_expr();
  ::pg_query::CaseExpr* mutable_case_expr();
  void set_allocated_case_expr(::pg_query::CaseExpr* case_expr);
  private:
  const ::pg_query::CaseExpr& _internal_case_expr() const;
  ::pg_query::CaseExpr* _internal_mutable_case_expr();
  public:
  void unsafe_arena_set_allocated_case_expr(
      ::pg_query::CaseExpr* case_expr);
  ::pg_query::CaseExpr* unsafe_arena_release_case_expr();

  // .pg_query.CaseWhen case_when = 29 [json_name = "CaseWhen"];
  bool has_case_when() const;
  private:
  bool _internal_has_case_when() const;
  public:
  void clear_case_when();
  const ::pg_query::CaseWhen& case_when() const;
  ::pg_query::CaseWhen* release_case_when();
  ::pg_query::CaseWhen* mutable_case_when();
  void set_allocated_case_when(::pg_query::CaseWhen* case_when);
  private:
  const ::pg_query::CaseWhen& _internal_case_when() const;
  ::pg_query::CaseWhen* _internal_mutable_case_when();
  public:
  void unsafe_arena_set_allocated_case_when(
      ::pg_query::CaseWhen* case_when);
  ::pg_query::CaseWhen* unsafe_arena_release_case_when();

  // .pg_query.CaseTestExpr case_test_expr = 30 [json_name = "CaseTestExpr"];
  bool has_case_test_expr() const;
  private:
  bool _internal_has_case_test_expr() const;
  public:
  void clear_case_test_expr();
  const ::pg_query::CaseTestExpr& case_test_expr() const;
  ::pg_query::CaseTestExpr* release_case_test_expr();
  ::pg_query::CaseTestExpr* mutable_case_test_expr();
  void set_allocated_case_test_expr(::pg_query::CaseTestExpr* case_test_expr);
  private:
  const ::pg_query::CaseTestExpr& _internal_case_test_expr() const;
  ::pg_query::CaseTestExpr* _internal_mutable_case_test_expr();
  public:
  void unsafe_arena_set_allocated_case_test_expr(
      ::pg_query::CaseTestExpr* case_test_expr);
  ::pg_query::CaseTestExpr* unsafe_arena_release_case_test_expr();

  // .pg_query.ArrayExpr array_expr = 31 [json_name = "ArrayExpr"];
  bool has_array_expr() const;
  private:
  bool _internal_has_array_expr() const;
  public:
  void clear_array_expr();
  const ::pg_query::ArrayExpr& array_expr() const;
  ::pg_query::ArrayExpr* release_array_expr();
  ::pg_query::ArrayExpr* mutable_array_expr();
  void set_allocated_array_expr(::pg_query::ArrayExpr* array_expr);
  private:
  const ::pg_query::ArrayExpr& _internal_array_expr() const;
  ::pg_query::ArrayExpr* _internal_mutable_array_expr();
  public:
  void unsafe_arena_set_allocated_array_expr(
      ::pg_query::ArrayExpr* array_expr);
  ::pg_query::ArrayExpr* unsafe_arena_release_array_expr();

  // .pg_query.RowExpr row_expr = 32 [json_name = "RowExpr"];
  bool has_row_expr() const;
  private:
  bool _internal_has_row_expr() const;
  public:
  void clear_row_expr();
  const ::pg_query::RowExpr& row_expr() const;
  ::pg_query::RowExpr* release_row_expr();
  ::pg_query::RowExpr* mutable_row_expr();
  void set_allocated_row_expr(::pg_query::RowExpr* row_expr);
  private:
  const ::pg_query::RowExpr& _internal_row_expr() const;
  ::pg_query::RowExpr* _internal_mutable_row_expr();
  public:
  void unsafe_arena_set_allocated_row_expr(
      ::pg_query::RowExpr* row_expr);
  ::pg_query::RowExpr* unsafe_arena_release_row_expr();

  // .pg_query.RowCompareExpr row_compare_expr = 33 [json_name = "RowCompareExpr"];
  bool has_row_compare_expr() const;
  private:
  bool _internal_has_row_compare_expr() const;
  public:
  void clear_row_compare_expr();
  const ::pg_query::RowCompareExpr& row_compare_expr() const;
  ::pg_query::RowCompareExpr* release_row_compare_expr();
  ::pg_query::RowCompareExpr* mutable_row_compare_expr();
  void set_allocated_row_compare_expr(::pg_query::RowCompareExpr* row_compare_expr);
  private:
  const ::pg_query::RowCompareExpr& _internal_row_compare_expr() const;
  ::pg_query::RowCompareExpr* _internal_mutable_row_compare_expr();
  public:
  void unsafe_arena_set_allocated_row_compare_expr(
      ::pg_query::RowCompareExpr* row_compare_expr);
  ::pg_query::RowCompareExpr* unsafe_arena_release_row_compare_expr();

  // .pg_query.CoalesceExpr coalesce_expr = 34 [json_name = "CoalesceExpr"];
  bool has_coalesce_expr() const;
  private:
  bool _internal_has_coalesce_expr() const;
  public:
  void clear_coalesce_expr();
  const ::pg_query::CoalesceExpr& coalesce_expr() const;
  ::pg_query::CoalesceExpr* release_coalesce_expr();
  ::pg_query::CoalesceExpr* mutable_coalesce_expr();
  void set_allocated_coalesce_expr(::pg_query::CoalesceExpr* coalesce_expr);
  private:
  const ::pg_query::CoalesceExpr& _internal_coalesce_expr() const;
  ::pg_query::CoalesceExpr* _internal_mutable_coalesce_expr();
  public:
  void unsafe_arena_set_allocated_coalesce_expr(
      ::pg_query::CoalesceExpr* coalesce_expr);
  ::pg_query::CoalesceExpr* unsafe_arena_release_coalesce_expr();

  // .pg_query.MinMaxExpr min_max_expr = 35 [json_name = "MinMaxExpr"];
  bool has_min_max_expr() const;
  private:
  bool _internal_has_min_max_expr() const;
  public:
  void clear_min_max_expr();
  const ::pg_query::MinMaxExpr& min_max_expr() const;
  ::pg_query::MinMaxExpr* release_min_max_expr();
  ::pg_query::MinMaxExpr* mutable_min_max_expr();
  void set_allocated_min_max_expr(::pg_query::MinMaxExpr* min_max_expr);
  private:
  const ::pg_query::MinMaxExpr& _internal_min_max_expr() const;
  ::pg_query::MinMaxExpr* _internal_mutable_min_max_expr();
  public:
  void unsafe_arena_set_allocated_min_max_expr(
      ::pg_query::MinMaxExpr* min_max_expr);
  ::pg_query::MinMaxExpr* unsafe_arena_release_min_max_expr();

  // .pg_query.SQLValueFunction sqlvalue_function = 36 [json_name = "SQLValueFunction"];
  bool has_sqlvalue_function() const;
  private:
  bool _internal_has_sqlvalue_function() const;
  public:
  void clear_sqlvalue_function();
  const ::pg_query::SQLValueFunction& sqlvalue_function() const;
  ::pg_query::SQLValueFunction* release_sqlvalue_function();
  ::pg_query::SQLValueFunction* mutable_sqlvalue_function();
  void set_allocated_sqlvalue_function(::pg_query::SQLValueFunction* sqlvalue_function);
  private:
  const ::pg_query::SQLValueFunction& _internal_sqlvalue_function() const;
  ::pg_query::SQLValueFunction* _internal_mutable_sqlvalue_function();
  public:
  void unsafe_arena_set_allocated_sqlvalue_function(
      ::pg_query::SQLValueFunction* sqlvalue_function);
  ::pg_query::SQLValueFunction* unsafe_arena_release_sqlvalue_function();

  // .pg_query.XmlExpr xml_expr = 37 [json_name = "XmlExpr"];
  bool has_xml_expr() const;
  private:
  bool _internal_has_xml_expr() const;
  public:
  void clear_xml_expr();
  const ::pg_query::XmlExpr& xml_expr() const;
  ::pg_query::XmlExpr* release_xml_expr();
  ::pg_query::XmlExpr* mutable_xml_expr();
  void set_allocated_xml_expr(::pg_query::XmlExpr* xml_expr);
  private:
  const ::pg_query::XmlExpr& _internal_xml_expr() const;
  ::pg_query::XmlExpr* _internal_mutable_xml_expr();
  public:
  void unsafe_arena_set_allocated_xml_expr(
      ::pg_query::XmlExpr* xml_expr);
  ::pg_query::XmlExpr* unsafe_arena_release_xml_expr();

  // .pg_query.NullTest null_test = 38 [json_name = "NullTest"];
  bool has_null_test() const;
  private:
  bool _internal_has_null_test() const;
  public:
  void clear_null_test();
  const ::pg_query::NullTest& null_test() const;
  ::pg_query::NullTest* release_null_test();
  ::pg_query::NullTest* mutable_null_test();
  void set_allocated_null_test(::pg_query::NullTest* null_test);
  private:
  const ::pg_query::NullTest& _internal_null_test() const;
  ::pg_query::NullTest* _internal_mutable_null_test();
  public:
  void unsafe_arena_set_allocated_null_test(
      ::pg_query::NullTest* null_test);
  ::pg_query::NullTest* unsafe_arena_release_null_test();

  // .pg_query.BooleanTest boolean_test = 39 [json_name = "BooleanTest"];
  bool has_boolean_test() const;
  private:
  bool _internal_has_boolean_test() const;
  public:
  void clear_boolean_test();
  const ::pg_query::BooleanTest& boolean_test() const;
  ::pg_query::BooleanTest* release_boolean_test();
  ::pg_query::BooleanTest* mutable_boolean_test();
  void set_allocated_boolean_test(::pg_query::BooleanTest* boolean_test);
  private:
  const ::pg_query::BooleanTest& _internal_boolean_test() const;
  ::pg_query::BooleanTest* _internal_mutable_boolean_test();
  public:
  void unsafe_arena_set_allocated_boolean_test(
      ::pg_query::BooleanTest* boolean_test);
  ::pg_query::BooleanTest* unsafe_arena_release_boolean_test();

  // .pg_query.CoerceToDomain coerce_to_domain = 40 [json_name = "CoerceToDomain"];
  bool has_coerce_to_domain() const;
  private:
  bool _internal_has_coerce_to_domain() const;
  public:
  void clear_coerce_to_domain();
  const ::pg_query::CoerceToDomain& coerce_to_domain() const;
  ::pg_query::CoerceToDomain* release_coerce_to_domain();
  ::pg_query::CoerceToDomain* mutable_coerce_to_domain();
  void set_allocated_coerce_to_domain(::pg_query::CoerceToDomain* coerce_to_domain);
  private:
  const ::pg_query::CoerceToDomain& _internal_coerce_to_domain() const;
  ::pg_query::CoerceToDomain* _internal_mutable_coerce_to_domain();
  public:
  void unsafe_arena_set_allocated_coerce_to_domain(
      ::pg_query::CoerceToDomain* coerce_to_domain);
  ::pg_query::CoerceToDomain* unsafe_arena_release_coerce_to_domain();

  // .pg_query.CoerceToDomainValue coerce_to_domain_value = 41 [json_name = "CoerceToDomainValue"];
  bool has_coerce_to_domain_value() const;
  private:
  bool _internal_has_coerce_to_domain_value() const;
  public:
  void clear_coerce_to_domain_value();
  const ::pg_query::CoerceToDomainValue& coerce_to_domain_value() const;
  ::pg_query::CoerceToDomainValue* release_coerce_to_domain_value();
  ::pg_query::CoerceToDomainValue* mutable_coerce_to_domain_value();
  void set_allocated_coerce_to_domain_value(::pg_query::CoerceToDomainValue* coerce_to_domain_value);
  private:
  const ::pg_query::CoerceToDomainValue& _internal_coerce_to_domain_value() const;
  ::pg_query::CoerceToDomainValue* _internal_mutable_coerce_to_domain_value();
  public:
  void unsafe_arena_set_allocated_coerce_to_domain_value(
      ::pg_query::CoerceToDomainValue* coerce_to_domain_value);
  ::pg_query::CoerceToDomainValue* unsafe_arena_release_coerce_to_domain_value();

  // .pg_query.SetToDefault set_to_default = 42 [json_name = "SetToDefault"];
  bool has_set_to_default() const;
  private:
  bool _internal_has_set_to_default() const;
  public:
  void clear_set_to_default();
  const ::pg_query::SetToDefault& set_to_default() const;
  ::pg_query::SetToDefault* release_set_to_default();
  ::pg_query::SetToDefault* mutable_set_to_default();
  void set_allocated_set_to_default(::pg_query::SetToDefault* set_to_default);
  private:
  const ::pg_query::SetToDefault& _internal_set_to_default() const;
  ::pg_query::SetToDefault* _internal_mutable_set_to_default();
  public:
  void unsafe_arena_set_allocated_set_to_default(
      ::pg_query::SetToDefault* set_to_default);
  ::pg_query::SetToDefault* unsafe_arena_release_set_to_default();

  // .pg_query.CurrentOfExpr current_of_expr = 43 [json_name = "CurrentOfExpr"];
  bool has_current_of_expr() const;
  private:
  bool _internal_has_current_of_expr() const;
  public:
  void clear_current_of_expr();
  const ::pg_query::CurrentOfExpr& current_of_expr() const;
  ::pg_query::CurrentOfExpr* release_current_of_expr();
  ::pg_query::CurrentOfExpr* mutable_current_of_expr();
  void set_allocated_current_of_expr(::pg_query::CurrentOfExpr* current_of_expr);
  private:
  const ::pg_query::CurrentOfExpr& _internal_current_of_expr() const;
  ::pg_query::CurrentOfExpr* _internal_mutable_current_of_expr();
  public:
  void unsafe_arena_set_allocated_current_of_expr(
      ::pg_query::CurrentOfExpr* current_of_expr);
  ::pg_query::CurrentOfExpr* unsafe_arena_release_current_of_expr();

  // .pg_query.NextValueExpr next_value_expr = 44 [json_name = "NextValueExpr"];
  bool has_next_value_expr() const;
  private:
  bool _internal_has_next_value_expr() const;
  public:
  void clear_next_value_expr();
  const ::pg_query::NextValueExpr& next_value_expr() const;
  ::pg_query::NextValueExpr* release_next_value_expr();
  ::pg_query::NextValueExpr* mutable_next_value_expr();
  void set_allocated_next_value_expr(::pg_query::NextValueExpr* next_value_expr);
  private:
  const ::pg_query::NextValueExpr& _internal_next_value_expr() const;
  ::pg_query::NextValueExpr* _internal_mutable_next_value_expr();
  public:
  void unsafe_arena_set_allocated_next_value_expr(
      ::pg_query::NextValueExpr* next_value_expr);
  ::pg_query::NextValueExpr* unsafe_arena_release_next_value_expr();

  // .pg_query.InferenceElem inference_elem = 45 [json_name = "InferenceElem"];
  bool has_inference_elem() const;
  private:
  bool _internal_has_inference_elem() const;
  public:
  void clear_inference_elem();
  const ::pg_query::InferenceElem& inference_elem() const;
  ::pg_query::InferenceElem* release_inference_elem();
  ::pg_query::InferenceElem* mutable_inference_elem();
  void set_allocated_inference_elem(::pg_query::InferenceElem* inference_elem);
  private:
  const ::pg_query::InferenceElem& _internal_inference_elem() const;
  ::pg_query::InferenceElem* _internal_mutable_inference_elem();
  public:
  void unsafe_arena_set_allocated_inference_elem(
      ::pg_query::InferenceElem* inference_elem);
  ::pg_query::InferenceElem* unsafe_arena_release_inference_elem();

  // .pg_query.TargetEntry target_entry = 46 [json_name = "TargetEntry"];
  bool has_target_entry() const;
  private:
  bool _internal_has_target_entry() const;
  public:
  void clear_target_entry();
  const ::pg_query::TargetEntry& target_entry() const;
  ::pg_query::TargetEntry* release_target_entry();
  ::pg_query::TargetEntry* mutable_target_entry();
  void set_allocated_target_entry(::pg_query::TargetEntry* target_entry);
  private:
  const ::pg_query::TargetEntry& _internal_target_entry() const;
  ::pg_query::TargetEntry* _internal_mutable_target_entry();
  public:
  void unsafe_arena_set_allocated_target_entry(
      ::pg_query::TargetEntry* target_entry);
  ::pg_query::TargetEntry* unsafe_arena_release_target_entry();

  // .pg_query.RangeTblRef range_tbl_ref = 47 [json_name = "RangeTblRef"];
  bool has_range_tbl_ref() const;
  private:
  bool _internal_has_range_tbl_ref() const;
  public:
  void clear_range_tbl_ref();
  const ::pg_query::RangeTblRef& range_tbl_ref() const;
  ::pg_query::RangeTblRef* release_range_tbl_ref();
  ::pg_query::RangeTblRef* mutable_range_tbl_ref();
  void set_allocated_range_tbl_ref(::pg_query::RangeTblRef* range_tbl_ref);
  private:
  const ::pg_query::RangeTblRef& _internal_range_tbl_ref() const;
  ::pg_query::RangeTblRef* _internal_mutable_range_tbl_ref();
  public:
  void unsafe_arena_set_allocated_range_tbl_ref(
      ::pg_query::RangeTblRef* range_tbl_ref);
  ::pg_query::RangeTblRef* unsafe_arena_release_range_tbl_ref();

  // .pg_query.JoinExpr join_expr = 48 [json_name = "JoinExpr"];
  bool has_join_expr() const;
  private:
  bool _internal_has_join_expr() const;
  public:
  void clear_join_expr();
  const ::pg_query::JoinExpr& join_expr() const;
  ::pg_query::JoinExpr* release_join_expr();
  ::pg_query::JoinExpr* mutable_join_expr();
  void set_allocated_join_expr(::pg_query::JoinExpr* join_expr);
  private:
  const ::pg_query::JoinExpr& _internal_join_expr() const;
  ::pg_query::JoinExpr* _internal_mutable_join_expr();
  public:
  void unsafe_arena_set_allocated_join_expr(
      ::pg_query::JoinExpr* join_expr);
  ::pg_query::JoinExpr* unsafe_arena_release_join_expr();

  // .pg_query.FromExpr from_expr = 49 [json_name = "FromExpr"];
  bool has_from_expr() const;
  private:
  bool _internal_has_from_expr() const;
  public:
  void clear_from_expr();
  const ::pg_query::FromExpr& from_expr() const;
  ::pg_query::FromExpr* release_from_expr();
  ::pg_query::FromExpr* mutable_from_expr();
  void set_allocated_from_expr(::pg_query::FromExpr* from_expr);
  private:
  const ::pg_query::FromExpr& _internal_from_expr() const;
  ::pg_query::FromExpr* _internal_mutable_from_expr();
  public:
  void unsafe_arena_set_allocated_from_expr(
      ::pg_query::FromExpr* from_expr);
  ::pg_query::FromExpr* unsafe_arena_release_from_expr();

  // .pg_query.OnConflictExpr on_conflict_expr = 50 [json_name = "OnConflictExpr"];
  bool has_on_conflict_expr() const;
  private:
  bool _internal_has_on_conflict_expr() const;
  public:
  void clear_on_conflict_expr();
  const ::pg_query::OnConflictExpr& on_conflict_expr() const;
  ::pg_query::OnConflictExpr* release_on_conflict_expr();
  ::pg_query::OnConflictExpr* mutable_on_conflict_expr();
  void set_allocated_on_conflict_expr(::pg_query::OnConflictExpr* on_conflict_expr);
  private:
  const ::pg_query::OnConflictExpr& _internal_on_conflict_expr() const;
  ::pg_query::OnConflictExpr* _internal_mutable_on_conflict_expr();
  public:
  void unsafe_arena_set_allocated_on_conflict_expr(
      ::pg_query::OnConflictExpr* on_conflict_expr);
  ::pg_query::OnConflictExpr* unsafe_arena_release_on_conflict_expr();

  // .pg_query.IntoClause into_clause = 51 [json_name = "IntoClause"];
  bool has_into_clause() const;
  private:
  bool _internal_has_into_clause() const;
  public:
  void clear_into_clause();
  const ::pg_query::IntoClause& into_clause() const;
  ::pg_query::IntoClause* release_into_clause();
  ::pg_query::IntoClause* mutable_into_clause();
  void set_allocated_into_clause(::pg_query::IntoClause* into_clause);
  private:
  const ::pg_query::IntoClause& _internal_into_clause() const;
  ::pg_query::IntoClause* _internal_mutable_into_clause();
  public:
  void unsafe_arena_set_allocated_into_clause(
      ::pg_query::IntoClause* into_clause);
  ::pg_query::IntoClause* unsafe_arena_release_into_clause();

  // .pg_query.RawStmt raw_stmt = 52 [json_name = "RawStmt"];
  bool has_raw_stmt() const;
  private:
  bool _internal_has_raw_stmt() const;
  public:
  void clear_raw_stmt();
  const ::pg_query::RawStmt& raw_stmt() const;
  ::pg_query::RawStmt* release_raw_stmt();
  ::pg_query::RawStmt* mutable_raw_stmt();
  void set_allocated_raw_stmt(::pg_query::RawStmt* raw_stmt);
  private:
  const ::pg_query::RawStmt& _internal_raw_stmt() const;
  ::pg_query::RawStmt* _internal_mutable_raw_stmt();
  public:
  void unsafe_arena_set_allocated_raw_stmt(
      ::pg_query::RawStmt* raw_stmt);
  ::pg_query::RawStmt* unsafe_arena_release_raw_stmt();

  // .pg_query.Query query = 53 [json_name = "Query"];
  bool has_query() const;
  private:
  bool _internal_has_query() const;
  public:
  void clear_query();
  const ::pg_query::Query& query() const;
  ::pg_query::Query* release_query();
  ::pg_query::Query* mutable_query();
  void set_allocated_query(::pg_query::Query* query);
  private:
  const ::pg_query::Query& _internal_query() const;
  ::pg_query::Query* _internal_mutable_query();
  public:
  void unsafe_arena_set_allocated_query(
      ::pg_query::Query* query);
  ::pg_query::Query* unsafe_arena_release_query();

  // .pg_query.InsertStmt insert_stmt = 54 [json_name = "InsertStmt"];
  bool has_insert_stmt() const;
  private:
  bool _internal_has_insert_stmt() const;
  public:
  void clear_insert_stmt();
  const ::pg_query::InsertStmt& insert_stmt() const;
  ::pg_query::InsertStmt* release_insert_stmt();
  ::pg_query::InsertStmt* mutable_insert_stmt();
  void set_allocated_insert_stmt(::pg_query::InsertStmt* insert_stmt);
  private:
  const ::pg_query::InsertStmt& _internal_insert_stmt() const;
  ::pg_query::InsertStmt* _internal_mutable_insert_stmt();
  public:
  void unsafe_arena_set_allocated_insert_stmt(
      ::pg_query::InsertStmt* insert_stmt);
  ::pg_query::InsertStmt* unsafe_arena_release_insert_stmt();

  // .pg_query.DeleteStmt delete_stmt = 55 [json_name = "DeleteStmt"];
  bool has_delete_stmt() const;
  private:
  bool _internal_has_delete_stmt() const;
  public:
  void clear_delete_stmt();
  const ::pg_query::DeleteStmt& delete_stmt() const;
  ::pg_query::DeleteStmt* release_delete_stmt();
  ::pg_query::DeleteStmt* mutable_delete_stmt();
  void set_allocated_delete_stmt(::pg_query::DeleteStmt* delete_stmt);
  private:
  const ::pg_query::DeleteStmt& _internal_delete_stmt() const;
  ::pg_query::DeleteStmt* _internal_mutable_delete_stmt();
  public:
  void unsafe_arena_set_allocated_delete_stmt(
      ::pg_query::DeleteStmt* delete_stmt);
  ::pg_query::DeleteStmt* unsafe_arena_release_delete_stmt();

  // .pg_query.UpdateStmt update_stmt = 56 [json_name = "UpdateStmt"];
  bool has_update_stmt() const;
  private:
  bool _internal_has_update_stmt() const;
  public:
  void clear_update_stmt();
  const ::pg_query::UpdateStmt& update_stmt() const;
  ::pg_query::UpdateStmt* release_update_stmt();
  ::pg_query::UpdateStmt* mutable_update_stmt();
  void set_allocated_update_stmt(::pg_query::UpdateStmt* update_stmt);
  private:
  const ::pg_query::UpdateStmt& _internal_update_stmt() const;
  ::pg_query::UpdateStmt* _internal_mutable_update_stmt();
  public:
  void unsafe_arena_set_allocated_update_stmt(
      ::pg_query::UpdateStmt* update_stmt);
  ::pg_query::UpdateStmt* unsafe_arena_release_update_stmt();

  // .pg_query.SelectStmt select_stmt = 57 [json_name = "SelectStmt"];
  bool has_select_stmt() const;
  private:
  bool _internal_has_select_stmt() const;
  public:
  void clear_select_stmt();
  const ::pg_query::SelectStmt& select_stmt() const;
  ::pg_query::SelectStmt* release_select_stmt();
  ::pg_query::SelectStmt* mutable_select_stmt();
  void set_allocated_select_stmt(::pg_query::SelectStmt* select_stmt);
  private:
  const ::pg_query::SelectStmt& _internal_select_stmt() const;
  ::pg_query::SelectStmt* _internal_mutable_select_stmt();
  public:
  void unsafe_arena_set_allocated_select_stmt(
      ::pg_query::SelectStmt* select_stmt);
  ::pg_query::SelectStmt* unsafe_arena_release_select_stmt();

  // .pg_query.AlterTableStmt alter_table_stmt = 58 [json_name = "AlterTableStmt"];
  bool has_alter_table_stmt() const;
  private:
  bool _internal_has_alter_table_stmt() const;
  public:
  void clear_alter_table_stmt();
  const ::pg_query::AlterTableStmt& alter_table_stmt() const;
  ::pg_query::AlterTableStmt* release_alter_table_stmt();
  ::pg_query::AlterTableStmt* mutable_alter_table_stmt();
  void set_allocated_alter_table_stmt(::pg_query::AlterTableStmt* alter_table_stmt);
  private:
  const ::pg_query::AlterTableStmt& _internal_alter_table_stmt() const;
  ::pg_query::AlterTableStmt* _internal_mutable_alter_table_stmt();
  public:
  void unsafe_arena_set_allocated_alter_table_stmt(
      ::pg_query::AlterTableStmt* alter_table_stmt);
  ::pg_query::AlterTableStmt* unsafe_arena_release_alter_table_stmt();

  // .pg_query.AlterTableCmd alter_table_cmd = 59 [json_name = "AlterTableCmd"];
  bool has_alter_table_cmd() const;
  private:
  bool _internal_has_alter_table_cmd() const;
  public:
  void clear_alter_table_cmd();
  const ::pg_query::AlterTableCmd& alter_table_cmd() const;
  ::pg_query::AlterTableCmd* release_alter_table_cmd();
  ::pg_query::AlterTableCmd* mutable_alter_table_cmd();
  void set_allocated_alter_table_cmd(::pg_query::AlterTableCmd* alter_table_cmd);
  private:
  const ::pg_query::AlterTableCmd& _internal_alter_table_cmd() const;
  ::pg_query::AlterTableCmd* _internal_mutable_alter_table_cmd();
  public:
  void unsafe_arena_set_allocated_alter_table_cmd(
      ::pg_query::AlterTableCmd* alter_table_cmd);
  ::pg_query::AlterTableCmd* unsafe_arena_release_alter_table_cmd();

  // .pg_query.AlterDomainStmt alter_domain_stmt = 60 [json_name = "AlterDomainStmt"];
  bool has_alter_domain_stmt() const;
  private:
  bool _internal_has_alter_domain_stmt() const;
  public:
  void clear_alter_domain_stmt();
  const ::pg_query::AlterDomainStmt& alter_domain_stmt() const;
  ::pg_query::AlterDomainStmt* release_alter_domain_stmt();
  ::pg_query::AlterDomainStmt* mutable_alter_domain_stmt();
  void set_allocated_alter_domain_stmt(::pg_query::AlterDomainStmt* alter_domain_stmt);
  private:
  const ::pg_query::AlterDomainStmt& _internal_alter_domain_stmt() const;
  ::pg_query::AlterDomainStmt* _internal_mutable_alter_domain_stmt();
  public:
  void unsafe_arena_set_allocated_alter_domain_stmt(
      ::pg_query::AlterDomainStmt* alter_domain_stmt);
  ::pg_query::AlterDomainStmt* unsafe_arena_release_alter_domain_stmt();

  // .pg_query.SetOperationStmt set_operation_stmt = 61 [json_name = "SetOperationStmt"];
  bool has_set_operation_stmt() const;
  private:
  bool _internal_has_set_operation_stmt() const;
  public:
  void clear_set_operation_stmt();
  const ::pg_query::SetOperationStmt& set_operation_stmt() const;
  ::pg_query::SetOperationStmt* release_set_operation_stmt();
  ::pg_query::SetOperationStmt* mutable_set_operation_stmt();
  void set_allocated_set_operation_stmt(::pg_query::SetOperationStmt* set_operation_stmt);
  private:
  const ::pg_query::SetOperationStmt& _internal_set_operation_stmt() const;
  ::pg_query::SetOperationStmt* _internal_mutable_set_operation_stmt();
  public:
  void unsafe_arena_set_allocated_set_operation_stmt(
      ::pg_query::SetOperationStmt* set_operation_stmt);
  ::pg_query::SetOperationStmt* unsafe_arena_release_set_operation_stmt();

  // .pg_query.GrantStmt grant_stmt = 62 [json_name = "GrantStmt"];
  bool has_grant_stmt() const;
  private:
  bool _internal_has_grant_stmt() const;
  public:
  void clear_grant_stmt();
  const ::pg_query::GrantStmt& grant_stmt() const;
  ::pg_query::GrantStmt* release_grant_stmt();
  ::pg_query::GrantStmt* mutable_grant_stmt();
  void set_allocated_grant_stmt(::pg_query::GrantStmt* grant_stmt);
  private:
  const ::pg_query::GrantStmt& _internal_grant_stmt() const;
  ::pg_query::GrantStmt* _internal_mutable_grant_stmt();
  public:
  void unsafe_arena_set_allocated_grant_stmt(
      ::pg_query::GrantStmt* grant_stmt);
  ::pg_query::GrantStmt* unsafe_arena_release_grant_stmt();

  // .pg_query.GrantRoleStmt grant_role_stmt = 63 [json_name = "GrantRoleStmt"];
  bool has_grant_role_stmt() const;
  private:
  bool _internal_has_grant_role_stmt() const;
  public:
  void clear_grant_role_stmt();
  const ::pg_query::GrantRoleStmt& grant_role_stmt() const;
  ::pg_query::GrantRoleStmt* release_grant_role_stmt();
  ::pg_query::GrantRoleStmt* mutable_grant_role_stmt();
  void set_allocated_grant_role_stmt(::pg_query::GrantRoleStmt* grant_role_stmt);
  private:
  const ::pg_query::GrantRoleStmt& _internal_grant_role_stmt() const;
  ::pg_query::GrantRoleStmt* _internal_mutable_grant_role_stmt();
  public:
  void unsafe_arena_set_allocated_grant_role_stmt(
      ::pg_query::GrantRoleStmt* grant_role_stmt);
  ::pg_query::GrantRoleStmt* unsafe_arena_release_grant_role_stmt();

  // .pg_query.AlterDefaultPrivilegesStmt alter_default_privileges_stmt = 64 [json_name = "AlterDefaultPrivilegesStmt"];
  bool has_alter_default_privileges_stmt() const;
  private:
  bool _internal_has_alter_default_privileges_stmt() const;
  public:
  void clear_alter_default_privileges_stmt();
  const ::pg_query::AlterDefaultPrivilegesStmt& alter_default_privileges_stmt() const;
  ::pg_query::AlterDefaultPrivilegesStmt* release_alter_default_privileges_stmt();
  ::pg_query::AlterDefaultPrivilegesStmt* mutable_alter_default_privileges_stmt();
  void set_allocated_alter_default_privileges_stmt(::pg_query::AlterDefaultPrivilegesStmt* alter_default_privileges_stmt);
  private:
  const ::pg_query::AlterDefaultPrivilegesStmt& _internal_alter_default_privileges_stmt() const;
  ::pg_query::AlterDefaultPrivilegesStmt* _internal_mutable_alter_default_privileges_stmt();
  public:
  void unsafe_arena_set_allocated_alter_default_privileges_stmt(
      ::pg_query::AlterDefaultPrivilegesStmt* alter_default_privileges_stmt);
  ::pg_query::AlterDefaultPrivilegesStmt* unsafe_arena_release_alter_default_privileges_stmt();

  // .pg_query.ClosePortalStmt close_portal_stmt = 65 [json_name = "ClosePortalStmt"];
  bool has_close_portal_stmt() const;
  private:
  bool _internal_has_close_portal_stmt() const;
  public:
  void clear_close_portal_stmt();
  const ::pg_query::ClosePortalStmt& close_portal_stmt() const;
  ::pg_query::ClosePortalStmt* release_close_portal_stmt();
  ::pg_query::ClosePortalStmt* mutable_close_portal_stmt();
  void set_allocated_close_portal_stmt(::pg_query::ClosePortalStmt* close_portal_stmt);
  private:
  const ::pg_query::ClosePortalStmt& _internal_close_portal_stmt() const;
  ::pg_query::ClosePortalStmt* _internal_mutable_close_portal_stmt();
  public:
  void unsafe_arena_set_allocated_close_portal_stmt(
      ::pg_query::ClosePortalStmt* close_portal_stmt);
  ::pg_query::ClosePortalStmt* unsafe_arena_release_close_portal_stmt();

  // .pg_query.ClusterStmt cluster_stmt = 66 [json_name = "ClusterStmt"];
  bool has_cluster_stmt() const;
  private:
  bool _internal_has_cluster_stmt() const;
  public:
  void clear_cluster_stmt();
  const ::pg_query::ClusterStmt& cluster_stmt() const;
  ::pg_query::ClusterStmt* release_cluster_stmt();
  ::pg_query::ClusterStmt* mutable_cluster_stmt();
  void set_allocated_cluster_stmt(::pg_query::ClusterStmt* cluster_stmt);
  private:
  const ::pg_query::ClusterStmt& _internal_cluster_stmt() const;
  ::pg_query::ClusterStmt* _internal_mutable_cluster_stmt();
  public:
  void unsafe_arena_set_allocated_cluster_stmt(
      ::pg_query::ClusterStmt* cluster_stmt);
  ::pg_query::ClusterStmt* unsafe_arena_release_cluster_stmt();

  // .pg_query.CopyStmt copy_stmt = 67 [json_name = "CopyStmt"];
  bool has_copy_stmt() const;
  private:
  bool _internal_has_copy_stmt() const;
  public:
  void clear_copy_stmt();
  const ::pg_query::CopyStmt& copy_stmt() const;
  ::pg_query::CopyStmt* release_copy_stmt();
  ::pg_query::CopyStmt* mutable_copy_stmt();
  void set_allocated_copy_stmt(::pg_query::CopyStmt* copy_stmt);
  private:
  const ::pg_query::CopyStmt& _internal_copy_stmt() const;
  ::pg_query::CopyStmt* _internal_mutable_copy_stmt();
  public:
  void unsafe_arena_set_allocated_copy_stmt(
      ::pg_query::CopyStmt* copy_stmt);
  ::pg_query::CopyStmt* unsafe_arena_release_copy_stmt();

  // .pg_query.CreateStmt create_stmt = 68 [json_name = "CreateStmt"];
  bool has_create_stmt() const;
  private:
  bool _internal_has_create_stmt() const;
  public:
  void clear_create_stmt();
  const ::pg_query::CreateStmt& create_stmt() const;
  ::pg_query::CreateStmt* release_create_stmt();
  ::pg_query::CreateStmt* mutable_create_stmt();
  void set_allocated_create_stmt(::pg_query::CreateStmt* create_stmt);
  private:
  const ::pg_query::CreateStmt& _internal_create_stmt() const;
  ::pg_query::CreateStmt* _internal_mutable_create_stmt();
  public:
  void unsafe_arena_set_allocated_create_stmt(
      ::pg_query::CreateStmt* create_stmt);
  ::pg_query::CreateStmt* unsafe_arena_release_create_stmt();

  // .pg_query.DefineStmt define_stmt = 69 [json_name = "DefineStmt"];
  bool has_define_stmt() const;
  private:
  bool _internal_has_define_stmt() const;
  public:
  void clear_define_stmt();
  const ::pg_query::DefineStmt& define_stmt() const;
  ::pg_query::DefineStmt* release_define_stmt();
  ::pg_query::DefineStmt* mutable_define_stmt();
  void set_allocated_define_stmt(::pg_query::DefineStmt* define_stmt);
  private:
  const ::pg_query::DefineStmt& _internal_define_stmt() const;
  ::pg_query::DefineStmt* _internal_mutable_define_stmt();
  public:
  void unsafe_arena_set_allocated_define_stmt(
      ::pg_query::DefineStmt* define_stmt);
  ::pg_query::DefineStmt* unsafe_arena_release_define_stmt();

  // .pg_query.DropStmt drop_stmt = 70 [json_name = "DropStmt"];
  bool has_drop_stmt() const;
  private:
  bool _internal_has_drop_stmt() const;
  public:
  void clear_drop_stmt();
  const ::pg_query::DropStmt& drop_stmt() const;
  ::pg_query::DropStmt* release_drop_stmt();
  ::pg_query::DropStmt* mutable_drop_stmt();
  void set_allocated_drop_stmt(::pg_query::DropStmt* drop_stmt);
  private:
  const ::pg_query::DropStmt& _internal_drop_stmt() const;
  ::pg_query::DropStmt* _internal_mutable_drop_stmt();
  public:
  void unsafe_arena_set_allocated_drop_stmt(
      ::pg_query::DropStmt* drop_stmt);
  ::pg_query::DropStmt* unsafe_arena_release_drop_stmt();

  // .pg_query.TruncateStmt truncate_stmt = 71 [json_name = "TruncateStmt"];
  bool has_truncate_stmt() const;
  private:
  bool _internal_has_truncate_stmt() const;
  public:
  void clear_truncate_stmt();
  const ::pg_query::TruncateStmt& truncate_stmt() const;
  ::pg_query::TruncateStmt* release_truncate_stmt();
  ::pg_query::TruncateStmt* mutable_truncate_stmt();
  void set_allocated_truncate_stmt(::pg_query::TruncateStmt* truncate_stmt);
  private:
  const ::pg_query::TruncateStmt& _internal_truncate_stmt() const;
  ::pg_query::TruncateStmt* _internal_mutable_truncate_stmt();
  public:
  void unsafe_arena_set_allocated_truncate_stmt(
      ::pg_query::TruncateStmt* truncate_stmt);
  ::pg_query::TruncateStmt* unsafe_arena_release_truncate_stmt();

  // .pg_query.CommentStmt comment_stmt = 72 [json_name = "CommentStmt"];
  bool has_comment_stmt() const;
  private:
  bool _internal_has_comment_stmt() const;
  public:
  void clear_comment_stmt();
  const ::pg_query::CommentStmt& comment_stmt() const;
  ::pg_query::CommentStmt* release_comment_stmt();
  ::pg_query::CommentStmt* mutable_comment_stmt();
  void set_allocated_comment_stmt(::pg_query::CommentStmt* comment_stmt);
  private:
  const ::pg_query::CommentStmt& _internal_comment_stmt() const;
  ::pg_query::CommentStmt* _internal_mutable_comment_stmt();
  public:
  void unsafe_arena_set_allocated_comment_stmt(
      ::pg_query::CommentStmt* comment_stmt);
  ::pg_query::CommentStmt* unsafe_arena_release_comment_stmt();

  // .pg_query.FetchStmt fetch_stmt = 73 [json_name = "FetchStmt"];
  bool has_fetch_stmt() const;
  private:
  bool _internal_has_fetch_stmt() const;
  public:
  void clear_fetch_stmt();
  const ::pg_query::FetchStmt& fetch_stmt() const;
  ::pg_query::FetchStmt* release_fetch_stmt();
  ::pg_query::FetchStmt* mutable_fetch_stmt();
  void set_allocated_fetch_stmt(::pg_query::FetchStmt* fetch_stmt);
  private:
  const ::pg_query::FetchStmt& _internal_fetch_stmt() const;
  ::pg_query::FetchStmt* _internal_mutable_fetch_stmt();
  public:
  void unsafe_arena_set_allocated_fetch_stmt(
      ::pg_query::FetchStmt* fetch_stmt);
  ::pg_query::FetchStmt* unsafe_arena_release_fetch_stmt();

  // .pg_query.IndexStmt index_stmt = 74 [json_name = "IndexStmt"];
  bool has_index_stmt() const;
  private:
  bool _internal_has_index_stmt() const;
  public:
  void clear_index_stmt();
  const ::pg_query::IndexStmt& index_stmt() const;
  ::pg_query::IndexStmt* release_index_stmt();
  ::pg_query::IndexStmt* mutable_index_stmt();
  void set_allocated_index_stmt(::pg_query::IndexStmt* index_stmt);
  private:
  const ::pg_query::IndexStmt& _internal_index_stmt() const;
  ::pg_query::IndexStmt* _internal_mutable_index_stmt();
  public:
  void unsafe_arena_set_allocated_index_stmt(
      ::pg_query::IndexStmt* index_stmt);
  ::pg_query::IndexStmt* unsafe_arena_release_index_stmt();

  // .pg_query.CreateFunctionStmt create_function_stmt = 75 [json_name = "CreateFunctionStmt"];
  bool has_create_function_stmt() const;
  private:
  bool _internal_has_create_function_stmt() const;
  public:
  void clear_create_function_stmt();
  const ::pg_query::CreateFunctionStmt& create_function_stmt() const;
  ::pg_query::CreateFunctionStmt* release_create_function_stmt();
  ::pg_query::CreateFunctionStmt* mutable_create_function_stmt();
  void set_allocated_create_function_stmt(::pg_query::CreateFunctionStmt* create_function_stmt);
  private:
  const ::pg_query::CreateFunctionStmt& _internal_create_function_stmt() const;
  ::pg_query::CreateFunctionStmt* _internal_mutable_create_function_stmt();
  public:
  void unsafe_arena_set_allocated_create_function_stmt(
      ::pg_query::CreateFunctionStmt* create_function_stmt);
  ::pg_query::CreateFunctionStmt* unsafe_arena_release_create_function_stmt();

  // .pg_query.AlterFunctionStmt alter_function_stmt = 76 [json_name = "AlterFunctionStmt"];
  bool has_alter_function_stmt() const;
  private:
  bool _internal_has_alter_function_stmt() const;
  public:
  void clear_alter_function_stmt();
  const ::pg_query::AlterFunctionStmt& alter_function_stmt() const;
  ::pg_query::AlterFunctionStmt* release_alter_function_stmt();
  ::pg_query::AlterFunctionStmt* mutable_alter_function_stmt();
  void set_allocated_alter_function_stmt(::pg_query::AlterFunctionStmt* alter_function_stmt);
  private:
  const ::pg_query::AlterFunctionStmt& _internal_alter_function_stmt() const;
  ::pg_query::AlterFunctionStmt* _internal_mutable_alter_function_stmt();
  public:
  void unsafe_arena_set_allocated_alter_function_stmt(
      ::pg_query::AlterFunctionStmt* alter_function_stmt);
  ::pg_query::AlterFunctionStmt* unsafe_arena_release_alter_function_stmt();

  // .pg_query.DoStmt do_stmt = 77 [json_name = "DoStmt"];
  bool has_do_stmt() const;
  private:
  bool _internal_has_do_stmt() const;
  public:
  void clear_do_stmt();
  const ::pg_query::DoStmt& do_stmt() const;
  ::pg_query::DoStmt* release_do_stmt();
  ::pg_query::DoStmt* mutable_do_stmt();
  void set_allocated_do_stmt(::pg_query::DoStmt* do_stmt);
  private:
  const ::pg_query::DoStmt& _internal_do_stmt() const;
  ::pg_query::DoStmt* _internal_mutable_do_stmt();
  public:
  void unsafe_arena_set_allocated_do_stmt(
      ::pg_query::DoStmt* do_stmt);
  ::pg_query::DoStmt* unsafe_arena_release_do_stmt();

  // .pg_query.RenameStmt rename_stmt = 78 [json_name = "RenameStmt"];
  bool has_rename_stmt() const;
  private:
  bool _internal_has_rename_stmt() const;
  public:
  void clear_rename_stmt();
  const ::pg_query::RenameStmt& rename_stmt() const;
  ::pg_query::RenameStmt* release_rename_stmt();
  ::pg_query::RenameStmt* mutable_rename_stmt();
  void set_allocated_rename_stmt(::pg_query::RenameStmt* rename_stmt);
  private:
  const ::pg_query::RenameStmt& _internal_rename_stmt() const;
  ::pg_query::RenameStmt* _internal_mutable_rename_stmt();
  public:
  void unsafe_arena_set_allocated_rename_stmt(
      ::pg_query::RenameStmt* rename_stmt);
  ::pg_query::RenameStmt* unsafe_arena_release_rename_stmt();

  // .pg_query.RuleStmt rule_stmt = 79 [json_name = "RuleStmt"];
  bool has_rule_stmt() const;
  private:
  bool _internal_has_rule_stmt() const;
  public:
  void clear_rule_stmt();
  const ::pg_query::RuleStmt& rule_stmt() const;
  ::pg_query::RuleStmt* release_rule_stmt();
  ::pg_query::RuleStmt* mutable_rule_stmt();
  void set_allocated_rule_stmt(::pg_query::RuleStmt* rule_stmt);
  private:
  const ::pg_query::RuleStmt& _internal_rule_stmt() const;
  ::pg_query::RuleStmt* _internal_mutable_rule_stmt();
  public:
  void unsafe_arena_set_allocated_rule_stmt(
      ::pg_query::RuleStmt* rule_stmt);
  ::pg_query::RuleStmt* unsafe_arena_release_rule_stmt();

  // .pg_query.NotifyStmt notify_stmt = 80 [json_name = "NotifyStmt"];
  bool has_notify_stmt() const;
  private:
  bool _internal_has_notify_stmt() const;
  public:
  void clear_notify_stmt();
  const ::pg_query::NotifyStmt& notify_stmt() const;
  ::pg_query::NotifyStmt* release_notify_stmt();
  ::pg_query::NotifyStmt* mutable_notify_stmt();
  void set_allocated_notify_stmt(::pg_query::NotifyStmt* notify_stmt);
  private:
  const ::pg_query::NotifyStmt& _internal_notify_stmt() const;
  ::pg_query::NotifyStmt* _internal_mutable_notify_stmt();
  public:
  void unsafe_arena_set_allocated_notify_stmt(
      ::pg_query::NotifyStmt* notify_stmt);
  ::pg_query::NotifyStmt* unsafe_arena_release_notify_stmt();

  // .pg_query.ListenStmt listen_stmt = 81 [json_name = "ListenStmt"];
  bool has_listen_stmt() const;
  private:
  bool _internal_has_listen_stmt() const;
  public:
  void clear_listen_stmt();
  const ::pg_query::ListenStmt& listen_stmt() const;
  ::pg_query::ListenStmt* release_listen_stmt();
  ::pg_query::ListenStmt* mutable_listen_stmt();
  void set_allocated_listen_stmt(::pg_query::ListenStmt* listen_stmt);
  private:
  const ::pg_query::ListenStmt& _internal_listen_stmt() const;
  ::pg_query::ListenStmt* _internal_mutable_listen_stmt();
  public:
  void unsafe_arena_set_allocated_listen_stmt(
      ::pg_query::ListenStmt* listen_stmt);
  ::pg_query::ListenStmt* unsafe_arena_release_listen_stmt();

  // .pg_query.UnlistenStmt unlisten_stmt = 82 [json_name = "UnlistenStmt"];
  bool has_unlisten_stmt() const;
  private:
  bool _internal_has_unlisten_stmt() const;
  public:
  void clear_unlisten_stmt();
  const ::pg_query::UnlistenStmt& unlisten_stmt() const;
  ::pg_query::UnlistenStmt* release_unlisten_stmt();
  ::pg_query::UnlistenStmt* mutable_unlisten_stmt();
  void set_allocated_unlisten_stmt(::pg_query::UnlistenStmt* unlisten_stmt);
  private:
  const ::pg_query::UnlistenStmt& _internal_unlisten_stmt() const;
  ::pg_query::UnlistenStmt* _internal_mutable_unlisten_stmt();
  public:
  void unsafe_arena_set_allocated_unlisten_stmt(
      ::pg_query::UnlistenStmt* unlisten_stmt);
  ::pg_query::UnlistenStmt* unsafe_arena_release_unlisten_stmt();

  // .pg_query.TransactionStmt transaction_stmt = 83 [json_name = "TransactionStmt"];
  bool has_transaction_stmt() const;
  private:
  bool _internal_has_transaction_stmt() const;
  public:
  void clear_transaction_stmt();
  const ::pg_query::TransactionStmt& transaction_stmt() const;
  ::pg_query::TransactionStmt* release_transaction_stmt();
  ::pg_query::TransactionStmt* mutable_transaction_stmt();
  void set_allocated_transaction_stmt(::pg_query::TransactionStmt* transaction_stmt);
  private:
  const ::pg_query::TransactionStmt& _internal_transaction_stmt() const;
  ::pg_query::TransactionStmt* _internal_mutable_transaction_stmt();
  public:
  void unsafe_arena_set_allocated_transaction_stmt(
      ::pg_query::TransactionStmt* transaction_stmt);
  ::pg_query::TransactionStmt* unsafe_arena_release_transaction_stmt();

  // .pg_query.ViewStmt view_stmt = 84 [json_name = "ViewStmt"];
  bool has_view_stmt() const;
  private:
  bool _internal_has_view_stmt() const;
  public:
  void clear_view_stmt();
  const ::pg_query::ViewStmt& view_stmt() const;
  ::pg_query::ViewStmt* release_view_stmt();
  ::pg_query::ViewStmt* mutable_view_stmt();
  void set_allocated_view_stmt(::pg_query::ViewStmt* view_stmt);
  private:
  const ::pg_query::ViewStmt& _internal_view_stmt() const;
  ::pg_query::ViewStmt* _internal_mutable_view_stmt();
  public:
  void unsafe_arena_set_allocated_view_stmt(
      ::pg_query::ViewStmt* view_stmt);
  ::pg_query::ViewStmt* unsafe_arena_release_view_stmt();

  // .pg_query.LoadStmt load_stmt = 85 [json_name = "LoadStmt"];
  bool has_load_stmt() const;
  private:
  bool _internal_has_load_stmt() const;
  public:
  void clear_load_stmt();
  const ::pg_query::LoadStmt& load_stmt() const;
  ::pg_query::LoadStmt* release_load_stmt();
  ::pg_query::LoadStmt* mutable_load_stmt();
  void set_allocated_load_stmt(::pg_query::LoadStmt* load_stmt);
  private:
  const ::pg_query::LoadStmt& _internal_load_stmt() const;
  ::pg_query::LoadStmt* _internal_mutable_load_stmt();
  public:
  void unsafe_arena_set_allocated_load_stmt(
      ::pg_query::LoadStmt* load_stmt);
  ::pg_query::LoadStmt* unsafe_arena_release_load_stmt();

  // .pg_query.CreateDomainStmt create_domain_stmt = 86 [json_name = "CreateDomainStmt"];
  bool has_create_domain_stmt() const;
  private:
  bool _internal_has_create_domain_stmt() const;
  public:
  void clear_create_domain_stmt();
  const ::pg_query::CreateDomainStmt& create_domain_stmt() const;
  ::pg_query::CreateDomainStmt* release_create_domain_stmt();
  ::pg_query::CreateDomainStmt* mutable_create_domain_stmt();
  void set_allocated_create_domain_stmt(::pg_query::CreateDomainStmt* create_domain_stmt);
  private:
  const ::pg_query::CreateDomainStmt& _internal_create_domain_stmt() const;
  ::pg_query::CreateDomainStmt* _internal_mutable_create_domain_stmt();
  public:
  void unsafe_arena_set_allocated_create_domain_stmt(
      ::pg_query::CreateDomainStmt* create_domain_stmt);
  ::pg_query::CreateDomainStmt* unsafe_arena_release_create_domain_stmt();

  // .pg_query.CreatedbStmt createdb_stmt = 87 [json_name = "CreatedbStmt"];
  bool has_createdb_stmt() const;
  private:
  bool _internal_has_createdb_stmt() const;
  public:
  void clear_createdb_stmt();
  const ::pg_query::CreatedbStmt& createdb_stmt() const;
  ::pg_query::CreatedbStmt* release_createdb_stmt();
  ::pg_query::CreatedbStmt* mutable_createdb_stmt();
  void set_allocated_createdb_stmt(::pg_query::CreatedbStmt* createdb_stmt);
  private:
  const ::pg_query::CreatedbStmt& _internal_createdb_stmt() const;
  ::pg_query::CreatedbStmt* _internal_mutable_createdb_stmt();
  public:
  void unsafe_arena_set_allocated_createdb_stmt(
      ::pg_query::CreatedbStmt* createdb_stmt);
  ::pg_query::CreatedbStmt* unsafe_arena_release_createdb_stmt();

  // .pg_query.DropdbStmt dropdb_stmt = 88 [json_name = "DropdbStmt"];
  bool has_dropdb_stmt() const;
  private:
  bool _internal_has_dropdb_stmt() const;
  public:
  void clear_dropdb_stmt();
  const ::pg_query::DropdbStmt& dropdb_stmt() const;
  ::pg_query::DropdbStmt* release_dropdb_stmt();
  ::pg_query::DropdbStmt* mutable_dropdb_stmt();
  void set_allocated_dropdb_stmt(::pg_query::DropdbStmt* dropdb_stmt);
  private:
  const ::pg_query::DropdbStmt& _internal_dropdb_stmt() const;
  ::pg_query::DropdbStmt* _internal_mutable_dropdb_stmt();
  public:
  void unsafe_arena_set_allocated_dropdb_stmt(
      ::pg_query::DropdbStmt* dropdb_stmt);
  ::pg_query::DropdbStmt* unsafe_arena_release_dropdb_stmt();

  // .pg_query.VacuumStmt vacuum_stmt = 89 [json_name = "VacuumStmt"];
  bool has_vacuum_stmt() const;
  private:
  bool _internal_has_vacuum_stmt() const;
  public:
  void clear_vacuum_stmt();
  const ::pg_query::VacuumStmt& vacuum_stmt() const;
  ::pg_query::VacuumStmt* release_vacuum_stmt();
  ::pg_query::VacuumStmt* mutable_vacuum_stmt();
  void set_allocated_vacuum_stmt(::pg_query::VacuumStmt* vacuum_stmt);
  private:
  const ::pg_query::VacuumStmt& _internal_vacuum_stmt() const;
  ::pg_query::VacuumStmt* _internal_mutable_vacuum_stmt();
  public:
  void unsafe_arena_set_allocated_vacuum_stmt(
      ::pg_query::VacuumStmt* vacuum_stmt);
  ::pg_query::VacuumStmt* unsafe_arena_release_vacuum_stmt();

  // .pg_query.ExplainStmt explain_stmt = 90 [json_name = "ExplainStmt"];
  bool has_explain_stmt() const;
  private:
  bool _internal_has_explain_stmt() const;
  public:
  void clear_explain_stmt();
  const ::pg_query::ExplainStmt& explain_stmt() const;
  ::pg_query::ExplainStmt* release_explain_stmt();
  ::pg_query::ExplainStmt* mutable_explain_stmt();
  void set_allocated_explain_stmt(::pg_query::ExplainStmt* explain_stmt);
  private:
  const ::pg_query::ExplainStmt& _internal_explain_stmt() const;
  ::pg_query::ExplainStmt* _internal_mutable_explain_stmt();
  public:
  void unsafe_arena_set_allocated_explain_stmt(
      ::pg_query::ExplainStmt* explain_stmt);
  ::pg_query::ExplainStmt* unsafe_arena_release_explain_stmt();

  // .pg_query.CreateTableAsStmt create_table_as_stmt = 91 [json_name = "CreateTableAsStmt"];
  bool has_create_table_as_stmt() const;
  private:
  bool _internal_has_create_table_as_stmt() const;
  public:
  void clear_create_table_as_stmt();
  const ::pg_query::CreateTableAsStmt& create_table_as_stmt() const;
  ::pg_query::CreateTableAsStmt* release_create_table_as_stmt();
  ::pg_query::CreateTableAsStmt* mutable_create_table_as_stmt();
  void set_allocated_create_table_as_stmt(::pg_query::CreateTableAsStmt* create_table_as_stmt);
  private:
  const ::pg_query::CreateTableAsStmt& _internal_create_table_as_stmt() const;
  ::pg_query::CreateTableAsStmt* _internal_mutable_create_table_as_stmt();
  public:
  void unsafe_arena_set_allocated_create_table_as_stmt(
      ::pg_query::CreateTableAsStmt* create_table_as_stmt);
  ::pg_query::CreateTableAsStmt* unsafe_arena_release_create_table_as_stmt();

  // .pg_query.CreateSeqStmt create_seq_stmt = 92 [json_name = "CreateSeqStmt"];
  bool has_create_seq_stmt() const;
  private:
  bool _internal_has_create_seq_stmt() const;
  public:
  void clear_create_seq_stmt();
  const ::pg_query::CreateSeqStmt& create_seq_stmt() const;
  ::pg_query::CreateSeqStmt* release_create_seq_stmt();
  ::pg_query::CreateSeqStmt* mutable_create_seq_stmt();
  void set_allocated_create_seq_stmt(::pg_query::CreateSeqStmt* create_seq_stmt);
  private:
  const ::pg_query::CreateSeqStmt& _internal_create_seq_stmt() const;
  ::pg_query::CreateSeqStmt* _internal_mutable_create_seq_stmt();
  public:
  void unsafe_arena_set_allocated_create_seq_stmt(
      ::pg_query::CreateSeqStmt* create_seq_stmt);
  ::pg_query::CreateSeqStmt* unsafe_arena_release_create_seq_stmt();

  // .pg_query.AlterSeqStmt alter_seq_stmt = 93 [json_name = "AlterSeqStmt"];
  bool has_alter_seq_stmt() const;
  private:
  bool _internal_has_alter_seq_stmt() const;
  public:
  void clear_alter_seq_stmt();
  const ::pg_query::AlterSeqStmt& alter_seq_stmt() const;
  ::pg_query::AlterSeqStmt* release_alter_seq_stmt();
  ::pg_query::AlterSeqStmt* mutable_alter_seq_stmt();
  void set_allocated_alter_seq_stmt(::pg_query::AlterSeqStmt* alter_seq_stmt);
  private:
  const ::pg_query::AlterSeqStmt& _internal_alter_seq_stmt() const;
  ::pg_query::AlterSeqStmt* _internal_mutable_alter_seq_stmt();
  public:
  void unsafe_arena_set_allocated_alter_seq_stmt(
      ::pg_query::AlterSeqStmt* alter_seq_stmt);
  ::pg_query::AlterSeqStmt* unsafe_arena_release_alter_seq_stmt();

  // .pg_query.VariableSetStmt variable_set_stmt = 94 [json_name = "VariableSetStmt"];
  bool has_variable_set_stmt() const;
  private:
  bool _internal_has_variable_set_stmt() const;
  public:
  void clear_variable_set_stmt();
  const ::pg_query::VariableSetStmt& variable_set_stmt() const;
  ::pg_query::VariableSetStmt* release_variable_set_stmt();
  ::pg_query::VariableSetStmt* mutable_variable_set_stmt();
  void set_allocated_variable_set_stmt(::pg_query::VariableSetStmt* variable_set_stmt);
  private:
  const ::pg_query::VariableSetStmt& _internal_variable_set_stmt() const;
  ::pg_query::VariableSetStmt* _internal_mutable_variable_set_stmt();
  public:
  void unsafe_arena_set_allocated_variable_set_stmt(
      ::pg_query::VariableSetStmt* variable_set_stmt);
  ::pg_query::VariableSetStmt* unsafe_arena_release_variable_set_stmt();

  // .pg_query.VariableShowStmt variable_show_stmt = 95 [json_name = "VariableShowStmt"];
  bool has_variable_show_stmt() const;
  private:
  bool _internal_has_variable_show_stmt() const;
  public:
  void clear_variable_show_stmt();
  const ::pg_query::VariableShowStmt& variable_show_stmt() const;
  ::pg_query::VariableShowStmt* release_variable_show_stmt();
  ::pg_query::VariableShowStmt* mutable_variable_show_stmt();
  void set_allocated_variable_show_stmt(::pg_query::VariableShowStmt* variable_show_stmt);
  private:
  const ::pg_query::VariableShowStmt& _internal_variable_show_stmt() const;
  ::pg_query::VariableShowStmt* _internal_mutable_variable_show_stmt();
  public:
  void unsafe_arena_set_allocated_variable_show_stmt(
      ::pg_query::VariableShowStmt* variable_show_stmt);
  ::pg_query::VariableShowStmt* unsafe_arena_release_variable_show_stmt();

  // .pg_query.DiscardStmt discard_stmt = 96 [json_name = "DiscardStmt"];
  bool has_discard_stmt() const;
  private:
  bool _internal_has_discard_stmt() const;
  public:
  void clear_discard_stmt();
  const ::pg_query::DiscardStmt& discard_stmt() const;
  ::pg_query::DiscardStmt* release_discard_stmt();
  ::pg_query::DiscardStmt* mutable_discard_stmt();
  void set_allocated_discard_stmt(::pg_query::DiscardStmt* discard_stmt);
  private:
  const ::pg_query::DiscardStmt& _internal_discard_stmt() const;
  ::pg_query::DiscardStmt* _internal_mutable_discard_stmt();
  public:
  void unsafe_arena_set_allocated_discard_stmt(
      ::pg_query::DiscardStmt* discard_stmt);
  ::pg_query::DiscardStmt* unsafe_arena_release_discard_stmt();

  // .pg_query.CreateTrigStmt create_trig_stmt = 97 [json_name = "CreateTrigStmt"];
  bool has_create_trig_stmt() const;
  private:
  bool _internal_has_create_trig_stmt() const;
  public:
  void clear_create_trig_stmt();
  const ::pg_query::CreateTrigStmt& create_trig_stmt() const;
  ::pg_query::CreateTrigStmt* release_create_trig_stmt();
  ::pg_query::CreateTrigStmt* mutable_create_trig_stmt();
  void set_allocated_create_trig_stmt(::pg_query::CreateTrigStmt* create_trig_stmt);
  private:
  const ::pg_query::CreateTrigStmt& _internal_create_trig_stmt() const;
  ::pg_query::CreateTrigStmt* _internal_mutable_create_trig_stmt();
  public:
  void unsafe_arena_set_allocated_create_trig_stmt(
      ::pg_query::CreateTrigStmt* create_trig_stmt);
  ::pg_query::CreateTrigStmt* unsafe_arena_release_create_trig_stmt();

  // .pg_query.CreatePLangStmt create_plang_stmt = 98 [json_name = "CreatePLangStmt"];
  bool has_create_plang_stmt() const;
  private:
  bool _internal_has_create_plang_stmt() const;
  public:
  void clear_create_plang_stmt();
  const ::pg_query::CreatePLangStmt& create_plang_stmt() const;
  ::pg_query::CreatePLangStmt* release_create_plang_stmt();
  ::pg_query::CreatePLangStmt* mutable_create_plang_stmt();
  void set_allocated_create_plang_stmt(::pg_query::CreatePLangStmt* create_plang_stmt);
  private:
  const ::pg_query::CreatePLangStmt& _internal_create_plang_stmt() const;
  ::pg_query::CreatePLangStmt* _internal_mutable_create_plang_stmt();
  public:
  void unsafe_arena_set_allocated_create_plang_stmt(
      ::pg_query::CreatePLangStmt* create_plang_stmt);
  ::pg_query::CreatePLangStmt* unsafe_arena_release_create_plang_stmt();

  // .pg_query.CreateRoleStmt create_role_stmt = 99 [json_name = "CreateRoleStmt"];
  bool has_create_role_stmt() const;
  private:
  bool _internal_has_create_role_stmt() const;
  public:
  void clear_create_role_stmt();
  const ::pg_query::CreateRoleStmt& create_role_stmt() const;
  ::pg_query::CreateRoleStmt* release_create_role_stmt();
  ::pg_query::CreateRoleStmt* mutable_create_role_stmt();
  void set_allocated_create_role_stmt(::pg_query::CreateRoleStmt* create_role_stmt);
  private:
  const ::pg_query::CreateRoleStmt& _internal_create_role_stmt() const;
  ::pg_query::CreateRoleStmt* _internal_mutable_create_role_stmt();
  public:
  void unsafe_arena_set_allocated_create_role_stmt(
      ::pg_query::CreateRoleStmt* create_role_stmt);
  ::pg_query::CreateRoleStmt* unsafe_arena_release_create_role_stmt();

  // .pg_query.AlterRoleStmt alter_role_stmt = 100 [json_name = "AlterRoleStmt"];
  bool has_alter_role_stmt() const;
  private:
  bool _internal_has_alter_role_stmt() const;
  public:
  void clear_alter_role_stmt();
  const ::pg_query::AlterRoleStmt& alter_role_stmt() const;
  ::pg_query::AlterRoleStmt* release_alter_role_stmt();
  ::pg_query::AlterRoleStmt* mutable_alter_role_stmt();
  void set_allocated_alter_role_stmt(::pg_query::AlterRoleStmt* alter_role_stmt);
  private:
  const ::pg_query::AlterRoleStmt& _internal_alter_role_stmt() const;
  ::pg_query::AlterRoleStmt* _internal_mutable_alter_role_stmt();
  public:
  void unsafe_arena_set_allocated_alter_role_stmt(
      ::pg_query::AlterRoleStmt* alter_role_stmt);
  ::pg_query::AlterRoleStmt* unsafe_arena_release_alter_role_stmt();

  // .pg_query.DropRoleStmt drop_role_stmt = 101 [json_name = "DropRoleStmt"];
  bool has_drop_role_stmt() const;
  private:
  bool _internal_has_drop_role_stmt() const;
  public:
  void clear_drop_role_stmt();
  const ::pg_query::DropRoleStmt& drop_role_stmt() const;
  ::pg_query::DropRoleStmt* release_drop_role_stmt();
  ::pg_query::DropRoleStmt* mutable_drop_role_stmt();
  void set_allocated_drop_role_stmt(::pg_query::DropRoleStmt* drop_role_stmt);
  private:
  const ::pg_query::DropRoleStmt& _internal_drop_role_stmt() const;
  ::pg_query::DropRoleStmt* _internal_mutable_drop_role_stmt();
  public:
  void unsafe_arena_set_allocated_drop_role_stmt(
      ::pg_query::DropRoleStmt* drop_role_stmt);
  ::pg_query::DropRoleStmt* unsafe_arena_release_drop_role_stmt();

  // .pg_query.LockStmt lock_stmt = 102 [json_name = "LockStmt"];
  bool has_lock_stmt() const;
  private:
  bool _internal_has_lock_stmt() const;
  public:
  void clear_lock_stmt();
  const ::pg_query::LockStmt& lock_stmt() const;
  ::pg_query::LockStmt* release_lock_stmt();
  ::pg_query::LockStmt* mutable_lock_stmt();
  void set_allocated_lock_stmt(::pg_query::LockStmt* lock_stmt);
  private:
  const ::pg_query::LockStmt& _internal_lock_stmt() const;
  ::pg_query::LockStmt* _internal_mutable_lock_stmt();
  public:
  void unsafe_arena_set_allocated_lock_stmt(
      ::pg_query::LockStmt* lock_stmt);
  ::pg_query::LockStmt* unsafe_arena_release_lock_stmt();

  // .pg_query.ConstraintsSetStmt constraints_set_stmt = 103 [json_name = "ConstraintsSetStmt"];
  bool has_constraints_set_stmt() const;
  private:
  bool _internal_has_constraints_set_stmt() const;
  public:
  void clear_constraints_set_stmt();
  const ::pg_query::ConstraintsSetStmt& constraints_set_stmt() const;
  ::pg_query::ConstraintsSetStmt* release_constraints_set_stmt();
  ::pg_query::ConstraintsSetStmt* mutable_constraints_set_stmt();
  void set_allocated_constraints_set_stmt(::pg_query::ConstraintsSetStmt* constraints_set_stmt);
  private:
  const ::pg_query::ConstraintsSetStmt& _internal_constraints_set_stmt() const;
  ::pg_query::ConstraintsSetStmt* _internal_mutable_constraints_set_stmt();
  public:
  void unsafe_arena_set_allocated_constraints_set_stmt(
      ::pg_query::ConstraintsSetStmt* constraints_set_stmt);
  ::pg_query::ConstraintsSetStmt* unsafe_arena_release_constraints_set_stmt();

  // .pg_query.ReindexStmt reindex_stmt = 104 [json_name = "ReindexStmt"];
  bool has_reindex_stmt() const;
  private:
  bool _internal_has_reindex_stmt() const;
  public:
  void clear_reindex_stmt();
  const ::pg_query::ReindexStmt& reindex_stmt() const;
  ::pg_query::ReindexStmt* release_reindex_stmt();
  ::pg_query::ReindexStmt* mutable_reindex_stmt();
  void set_allocated_reindex_stmt(::pg_query::ReindexStmt* reindex_stmt);
  private:
  const ::pg_query::ReindexStmt& _internal_reindex_stmt() const;
  ::pg_query::ReindexStmt* _internal_mutable_reindex_stmt();
  public:
  void unsafe_arena_set_allocated_reindex_stmt(
      ::pg_query::ReindexStmt* reindex_stmt);
  ::pg_query::ReindexStmt* unsafe_arena_release_reindex_stmt();

  // .pg_query.CheckPointStmt check_point_stmt = 105 [json_name = "CheckPointStmt"];
  bool has_check_point_stmt() const;
  private:
  bool _internal_has_check_point_stmt() const;
  public:
  void clear_check_point_stmt();
  const ::pg_query::CheckPointStmt& check_point_stmt() const;
  ::pg_query::CheckPointStmt* release_check_point_stmt();
  ::pg_query::CheckPointStmt* mutable_check_point_stmt();
  void set_allocated_check_point_stmt(::pg_query::CheckPointStmt* check_point_stmt);
  private:
  const ::pg_query::CheckPointStmt& _internal_check_point_stmt() const;
  ::pg_query::CheckPointStmt* _internal_mutable_check_point_stmt();
  public:
  void unsafe_arena_set_allocated_check_point_stmt(
      ::pg_query::CheckPointStmt* check_point_stmt);
  ::pg_query::CheckPointStmt* unsafe_arena_release_check_point_stmt();

  // .pg_query.CreateSchemaStmt create_schema_stmt = 106 [json_name = "CreateSchemaStmt"];
  bool has_create_schema_stmt() const;
  private:
  bool _internal_has_create_schema_stmt() const;
  public:
  void clear_create_schema_stmt();
  const ::pg_query::CreateSchemaStmt& create_schema_stmt() const;
  ::pg_query::CreateSchemaStmt* release_create_schema_stmt();
  ::pg_query::CreateSchemaStmt* mutable_create_schema_stmt();
  void set_allocated_create_schema_stmt(::pg_query::CreateSchemaStmt* create_schema_stmt);
  private:
  const ::pg_query::CreateSchemaStmt& _internal_create_schema_stmt() const;
  ::pg_query::CreateSchemaStmt* _internal_mutable_create_schema_stmt();
  public:
  void unsafe_arena_set_allocated_create_schema_stmt(
      ::pg_query::CreateSchemaStmt* create_schema_stmt);
  ::pg_query::CreateSchemaStmt* unsafe_arena_release_create_schema_stmt();

  // .pg_query.AlterDatabaseStmt alter_database_stmt = 107 [json_name = "AlterDatabaseStmt"];
  bool has_alter_database_stmt() const;
  private:
  bool _internal_has_alter_database_stmt() const;
  public:
  void clear_alter_database_stmt();
  const ::pg_query::AlterDatabaseStmt& alter_database_stmt() const;
  ::pg_query::AlterDatabaseStmt* release_alter_database_stmt();
  ::pg_query::AlterDatabaseStmt* mutable_alter_database_stmt();
  void set_allocated_alter_database_stmt(::pg_query::AlterDatabaseStmt* alter_database_stmt);
  private:
  const ::pg_query::AlterDatabaseStmt& _internal_alter_database_stmt() const;
  ::pg_query::AlterDatabaseStmt* _internal_mutable_alter_database_stmt();
  public:
  void unsafe_arena_set_allocated_alter_database_stmt(
      ::pg_query::AlterDatabaseStmt* alter_database_stmt);
  ::pg_query::AlterDatabaseStmt* unsafe_arena_release_alter_database_stmt();

  // .pg_query.AlterDatabaseSetStmt alter_database_set_stmt = 108 [json_name = "AlterDatabaseSetStmt"];
  bool has_alter_database_set_stmt() const;
  private:
  bool _internal_has_alter_database_set_stmt() const;
  public:
  void clear_alter_database_set_stmt();
  const ::pg_query::AlterDatabaseSetStmt& alter_database_set_stmt() const;
  ::pg_query::AlterDatabaseSetStmt* release_alter_database_set_stmt();
  ::pg_query::AlterDatabaseSetStmt* mutable_alter_database_set_stmt();
  void set_allocated_alter_database_set_stmt(::pg_query::AlterDatabaseSetStmt* alter_database_set_stmt);
  private:
  const ::pg_query::AlterDatabaseSetStmt& _internal_alter_database_set_stmt() const;
  ::pg_query::AlterDatabaseSetStmt* _internal_mutable_alter_database_set_stmt();
  public:
  void unsafe_arena_set_allocated_alter_database_set_stmt(
      ::pg_query::AlterDatabaseSetStmt* alter_database_set_stmt);
  ::pg_query::AlterDatabaseSetStmt* unsafe_arena_release_alter_database_set_stmt();

  // .pg_query.AlterRoleSetStmt alter_role_set_stmt = 109 [json_name = "AlterRoleSetStmt"];
  bool has_alter_role_set_stmt() const;
  private:
  bool _internal_has_alter_role_set_stmt() const;
  public:
  void clear_alter_role_set_stmt();
  const ::pg_query::AlterRoleSetStmt& alter_role_set_stmt() const;
  ::pg_query::AlterRoleSetStmt* release_alter_role_set_stmt();
  ::pg_query::AlterRoleSetStmt* mutable_alter_role_set_stmt();
  void set_allocated_alter_role_set_stmt(::pg_query::AlterRoleSetStmt* alter_role_set_stmt);
  private:
  const ::pg_query::AlterRoleSetStmt& _internal_alter_role_set_stmt() const;
  ::pg_query::AlterRoleSetStmt* _internal_mutable_alter_role_set_stmt();
  public:
  void unsafe_arena_set_allocated_alter_role_set_stmt(
      ::pg_query::AlterRoleSetStmt* alter_role_set_stmt);
  ::pg_query::AlterRoleSetStmt* unsafe_arena_release_alter_role_set_stmt();

  // .pg_query.CreateConversionStmt create_conversion_stmt = 110 [json_name = "CreateConversionStmt"];
  bool has_create_conversion_stmt() const;
  private:
  bool _internal_has_create_conversion_stmt() const;
  public:
  void clear_create_conversion_stmt();
  const ::pg_query::CreateConversionStmt& create_conversion_stmt() const;
  ::pg_query::CreateConversionStmt* release_create_conversion_stmt();
  ::pg_query::CreateConversionStmt* mutable_create_conversion_stmt();
  void set_allocated_create_conversion_stmt(::pg_query::CreateConversionStmt* create_conversion_stmt);
  private:
  const ::pg_query::CreateConversionStmt& _internal_create_conversion_stmt() const;
  ::pg_query::CreateConversionStmt* _internal_mutable_create_conversion_stmt();
  public:
  void unsafe_arena_set_allocated_create_conversion_stmt(
      ::pg_query::CreateConversionStmt* create_conversion_stmt);
  ::pg_query::CreateConversionStmt* unsafe_arena_release_create_conversion_stmt();

  // .pg_query.CreateCastStmt create_cast_stmt = 111 [json_name = "CreateCastStmt"];
  bool has_create_cast_stmt() const;
  private:
  bool _internal_has_create_cast_stmt() const;
  public:
  void clear_create_cast_stmt();
  const ::pg_query::CreateCastStmt& create_cast_stmt() const;
  ::pg_query::CreateCastStmt* release_create_cast_stmt();
  ::pg_query::CreateCastStmt* mutable_create_cast_stmt();
  void set_allocated_create_cast_stmt(::pg_query::CreateCastStmt* create_cast_stmt);
  private:
  const ::pg_query::CreateCastStmt& _internal_create_cast_stmt() const;
  ::pg_query::CreateCastStmt* _internal_mutable_create_cast_stmt();
  public:
  void unsafe_arena_set_allocated_create_cast_stmt(
      ::pg_query::CreateCastStmt* create_cast_stmt);
  ::pg_query::CreateCastStmt* unsafe_arena_release_create_cast_stmt();

  // .pg_query.CreateOpClassStmt create_op_class_stmt = 112 [json_name = "CreateOpClassStmt"];
  bool has_create_op_class_stmt() const;
  private:
  bool _internal_has_create_op_class_stmt() const;
  public:
  void clear_create_op_class_stmt();
  const ::pg_query::CreateOpClassStmt& create_op_class_stmt() const;
  ::pg_query::CreateOpClassStmt* release_create_op_class_stmt();
  ::pg_query::CreateOpClassStmt* mutable_create_op_class_stmt();
  void set_allocated_create_op_class_stmt(::pg_query::CreateOpClassStmt* create_op_class_stmt);
  private:
  const ::pg_query::CreateOpClassStmt& _internal_create_op_class_stmt() const;
  ::pg_query::CreateOpClassStmt* _internal_mutable_create_op_class_stmt();
  public:
  void unsafe_arena_set_allocated_create_op_class_stmt(
      ::pg_query::CreateOpClassStmt* create_op_class_stmt);
  ::pg_query::CreateOpClassStmt* unsafe_arena_release_create_op_class_stmt();

  // .pg_query.CreateOpFamilyStmt create_op_family_stmt = 113 [json_name = "CreateOpFamilyStmt"];
  bool has_create_op_family_stmt() const;
  private:
  bool _internal_has_create_op_family_stmt() const;
  public:
  void clear_create_op_family_stmt();
  const ::pg_query::CreateOpFamilyStmt& create_op_family_stmt() const;
  ::pg_query::CreateOpFamilyStmt* release_create_op_family_stmt();
  ::pg_query::CreateOpFamilyStmt* mutable_create_op_family_stmt();
  void set_allocated_create_op_family_stmt(::pg_query::CreateOpFamilyStmt* create_op_family_stmt);
  private:
  const ::pg_query::CreateOpFamilyStmt& _internal_create_op_family_stmt() const;
  ::pg_query::CreateOpFamilyStmt* _internal_mutable_create_op_family_stmt();
  public:
  void unsafe_arena_set_allocated_create_op_family_stmt(
      ::pg_query::CreateOpFamilyStmt* create_op_family_stmt);
  ::pg_query::CreateOpFamilyStmt* unsafe_arena_release_create_op_family_stmt();

  // .pg_query.AlterOpFamilyStmt alter_op_family_stmt = 114 [json_name = "AlterOpFamilyStmt"];
  bool has_alter_op_family_stmt() const;
  private:
  bool _internal_has_alter_op_family_stmt() const;
  public:
  void clear_alter_op_family_stmt();
  const ::pg_query::AlterOpFamilyStmt& alter_op_family_stmt() const;
  ::pg_query::AlterOpFamilyStmt* release_alter_op_family_stmt();
  ::pg_query::AlterOpFamilyStmt* mutable_alter_op_family_stmt();
  void set_allocated_alter_op_family_stmt(::pg_query::AlterOpFamilyStmt* alter_op_family_stmt);
  private:
  const ::pg_query::AlterOpFamilyStmt& _internal_alter_op_family_stmt() const;
  ::pg_query::AlterOpFamilyStmt* _internal_mutable_alter_op_family_stmt();
  public:
  void unsafe_arena_set_allocated_alter_op_family_stmt(
      ::pg_query::AlterOpFamilyStmt* alter_op_family_stmt);
  ::pg_query::AlterOpFamilyStmt* unsafe_arena_release_alter_op_family_stmt();

  // .pg_query.PrepareStmt prepare_stmt = 115 [json_name = "PrepareStmt"];
  bool has_prepare_stmt() const;
  private:
  bool _internal_has_prepare_stmt() const;
  public:
  void clear_prepare_stmt();
  const ::pg_query::PrepareStmt& prepare_stmt() const;
  ::pg_query::PrepareStmt* release_prepare_stmt();
  ::pg_query::PrepareStmt* mutable_prepare_stmt();
  void set_allocated_prepare_stmt(::pg_query::PrepareStmt* prepare_stmt);
  private:
  const ::pg_query::PrepareStmt& _internal_prepare_stmt() const;
  ::pg_query::PrepareStmt* _internal_mutable_prepare_stmt();
  public:
  void unsafe_arena_set_allocated_prepare_stmt(
      ::pg_query::PrepareStmt* prepare_stmt);
  ::pg_query::PrepareStmt* unsafe_arena_release_prepare_stmt();

  // .pg_query.ExecuteStmt execute_stmt = 116 [json_name = "ExecuteStmt"];
  bool has_execute_stmt() const;
  private:
  bool _internal_has_execute_stmt() const;
  public:
  void clear_execute_stmt();
  const ::pg_query::ExecuteStmt& execute_stmt() const;
  ::pg_query::ExecuteStmt* release_execute_stmt();
  ::pg_query::ExecuteStmt* mutable_execute_stmt();
  void set_allocated_execute_stmt(::pg_query::ExecuteStmt* execute_stmt);
  private:
  const ::pg_query::ExecuteStmt& _internal_execute_stmt() const;
  ::pg_query::ExecuteStmt* _internal_mutable_execute_stmt();
  public:
  void unsafe_arena_set_allocated_execute_stmt(
      ::pg_query::ExecuteStmt* execute_stmt);
  ::pg_query::ExecuteStmt* unsafe_arena_release_execute_stmt();

  // .pg_query.DeallocateStmt deallocate_stmt = 117 [json_name = "DeallocateStmt"];
  bool has_deallocate_stmt() const;
  private:
  bool _internal_has_deallocate_stmt() const;
  public:
  void clear_deallocate_stmt();
  const ::pg_query::DeallocateStmt& deallocate_stmt() const;
  ::pg_query::DeallocateStmt* release_deallocate_stmt();
  ::pg_query::DeallocateStmt* mutable_deallocate_stmt();
  void set_allocated_deallocate_stmt(::pg_query::DeallocateStmt* deallocate_stmt);
  private:
  const ::pg_query::DeallocateStmt& _internal_deallocate_stmt() const;
  ::pg_query::DeallocateStmt* _internal_mutable_deallocate_stmt();
  public:
  void unsafe_arena_set_allocated_deallocate_stmt(
      ::pg_query::DeallocateStmt* deallocate_stmt);
  ::pg_query::DeallocateStmt* unsafe_arena_release_deallocate_stmt();

  // .pg_query.DeclareCursorStmt declare_cursor_stmt = 118 [json_name = "DeclareCursorStmt"];
  bool has_declare_cursor_stmt() const;
  private:
  bool _internal_has_declare_cursor_stmt() const;
  public:
  void clear_declare_cursor_stmt();
  const ::pg_query::DeclareCursorStmt& declare_cursor_stmt() const;
  ::pg_query::DeclareCursorStmt* release_declare_cursor_stmt();
  ::pg_query::DeclareCursorStmt* mutable_declare_cursor_stmt();
  void set_allocated_declare_cursor_stmt(::pg_query::DeclareCursorStmt* declare_cursor_stmt);
  private:
  const ::pg_query::DeclareCursorStmt& _internal_declare_cursor_stmt() const;
  ::pg_query::DeclareCursorStmt* _internal_mutable_declare_cursor_stmt();
  public:
  void unsafe_arena_set_allocated_declare_cursor_stmt(
      ::pg_query::DeclareCursorStmt* declare_cursor_stmt);
  ::pg_query::DeclareCursorStmt* unsafe_arena_release_declare_cursor_stmt();

  // .pg_query.CreateTableSpaceStmt create_table_space_stmt = 119 [json_name = "CreateTableSpaceStmt"];
  bool has_create_table_space_stmt() const;
  private:
  bool _internal_has_create_table_space_stmt() const;
  public:
  void clear_create_table_space_stmt();
  const ::pg_query::CreateTableSpaceStmt& create_table_space_stmt() const;
  ::pg_query::CreateTableSpaceStmt* release_create_table_space_stmt();
  ::pg_query::CreateTableSpaceStmt* mutable_create_table_space_stmt();
  void set_allocated_create_table_space_stmt(::pg_query::CreateTableSpaceStmt* create_table_space_stmt);
  private:
  const ::pg_query::CreateTableSpaceStmt& _internal_create_table_space_stmt() const;
  ::pg_query::CreateTableSpaceStmt* _internal_mutable_create_table_space_stmt();
  public:
  void unsafe_arena_set_allocated_create_table_space_stmt(
      ::pg_query::CreateTableSpaceStmt* create_table_space_stmt);
  ::pg_query::CreateTableSpaceStmt* unsafe_arena_release_create_table_space_stmt();

  // .pg_query.DropTableSpaceStmt drop_table_space_stmt = 120 [json_name = "DropTableSpaceStmt"];
  bool has_drop_table_space_stmt() const;
  private:
  bool _internal_has_drop_table_space_stmt() const;
  public:
  void clear_drop_table_space_stmt();
  const ::pg_query::DropTableSpaceStmt& drop_table_space_stmt() const;
  ::pg_query::DropTableSpaceStmt* release_drop_table_space_stmt();
  ::pg_query::DropTableSpaceStmt* mutable_drop_table_space_stmt();
  void set_allocated_drop_table_space_stmt(::pg_query::DropTableSpaceStmt* drop_table_space_stmt);
  private:
  const ::pg_query::DropTableSpaceStmt& _internal_drop_table_space_stmt() const;
  ::pg_query::DropTableSpaceStmt* _internal_mutable_drop_table_space_stmt();
  public:
  void unsafe_arena_set_allocated_drop_table_space_stmt(
      ::pg_query::DropTableSpaceStmt* drop_table_space_stmt);
  ::pg_query::DropTableSpaceStmt* unsafe_arena_release_drop_table_space_stmt();

  // .pg_query.AlterObjectDependsStmt alter_object_depends_stmt = 121 [json_name = "AlterObjectDependsStmt"];
  bool has_alter_object_depends_stmt() const;
  private:
  bool _internal_has_alter_object_depends_stmt() const;
  public:
  void clear_alter_object_depends_stmt();
  const ::pg_query::AlterObjectDependsStmt& alter_object_depends_stmt() const;
  ::pg_query::AlterObjectDependsStmt* release_alter_object_depends_stmt();
  ::pg_query::AlterObjectDependsStmt* mutable_alter_object_depends_stmt();
  void set_allocated_alter_object_depends_stmt(::pg_query::AlterObjectDependsStmt* alter_object_depends_stmt);
  private:
  const ::pg_query::AlterObjectDependsStmt& _internal_alter_object_depends_stmt() const;
  ::pg_query::AlterObjectDependsStmt* _internal_mutable_alter_object_depends_stmt();
  public:
  void unsafe_arena_set_allocated_alter_object_depends_stmt(
      ::pg_query::AlterObjectDependsStmt* alter_object_depends_stmt);
  ::pg_query::AlterObjectDependsStmt* unsafe_arena_release_alter_object_depends_stmt();

  // .pg_query.AlterObjectSchemaStmt alter_object_schema_stmt = 122 [json_name = "AlterObjectSchemaStmt"];
  bool has_alter_object_schema_stmt() const;
  private:
  bool _internal_has_alter_object_schema_stmt() const;
  public:
  void clear_alter_object_schema_stmt();
  const ::pg_query::AlterObjectSchemaStmt& alter_object_schema_stmt() const;
  ::pg_query::AlterObjectSchemaStmt* release_alter_object_schema_stmt();
  ::pg_query::AlterObjectSchemaStmt* mutable_alter_object_schema_stmt();
  void set_allocated_alter_object_schema_stmt(::pg_query::AlterObjectSchemaStmt* alter_object_schema_stmt);
  private:
  const ::pg_query::AlterObjectSchemaStmt& _internal_alter_object_schema_stmt() const;
  ::pg_query::AlterObjectSchemaStmt* _internal_mutable_alter_object_schema_stmt();
  public:
  void unsafe_arena_set_allocated_alter_object_schema_stmt(
      ::pg_query::AlterObjectSchemaStmt* alter_object_schema_stmt);
  ::pg_query::AlterObjectSchemaStmt* unsafe_arena_release_alter_object_schema_stmt();

  // .pg_query.AlterOwnerStmt alter_owner_stmt = 123 [json_name = "AlterOwnerStmt"];
  bool has_alter_owner_stmt() const;
  private:
  bool _internal_has_alter_owner_stmt() const;
  public:
  void clear_alter_owner_stmt();
  const ::pg_query::AlterOwnerStmt& alter_owner_stmt() const;
  ::pg_query::AlterOwnerStmt* release_alter_owner_stmt();
  ::pg_query::AlterOwnerStmt* mutable_alter_owner_stmt();
  void set_allocated_alter_owner_stmt(::pg_query::AlterOwnerStmt* alter_owner_stmt);
  private:
  const ::pg_query::AlterOwnerStmt& _internal_alter_owner_stmt() const;
  ::pg_query::AlterOwnerStmt* _internal_mutable_alter_owner_stmt();
  public:
  void unsafe_arena_set_allocated_alter_owner_stmt(
      ::pg_query::AlterOwnerStmt* alter_owner_stmt);
  ::pg_query::AlterOwnerStmt* unsafe_arena_release_alter_owner_stmt();

  // .pg_query.AlterOperatorStmt alter_operator_stmt = 124 [json_name = "AlterOperatorStmt"];
  bool has_alter_operator_stmt() const;
  private:
  bool _internal_has_alter_operator_stmt() const;
  public:
  void clear_alter_operator_stmt();
  const ::pg_query::AlterOperatorStmt& alter_operator_stmt() const;
  ::pg_query::AlterOperatorStmt* release_alter_operator_stmt();
  ::pg_query::AlterOperatorStmt* mutable_alter_operator_stmt();
  void set_allocated_alter_operator_stmt(::pg_query::AlterOperatorStmt* alter_operator_stmt);
  private:
  const ::pg_query::AlterOperatorStmt& _internal_alter_operator_stmt() const;
  ::pg_query::AlterOperatorStmt* _internal_mutable_alter_operator_stmt();
  public:
  void unsafe_arena_set_allocated_alter_operator_stmt(
      ::pg_query::AlterOperatorStmt* alter_operator_stmt);
  ::pg_query::AlterOperatorStmt* unsafe_arena_release_alter_operator_stmt();

  // .pg_query.AlterTypeStmt alter_type_stmt = 125 [json_name = "AlterTypeStmt"];
  bool has_alter_type_stmt() const;
  private:
  bool _internal_has_alter_type_stmt() const;
  public:
  void clear_alter_type_stmt();
  const ::pg_query::AlterTypeStmt& alter_type_stmt() const;
  ::pg_query::AlterTypeStmt* release_alter_type_stmt();
  ::pg_query::AlterTypeStmt* mutable_alter_type_stmt();
  void set_allocated_alter_type_stmt(::pg_query::AlterTypeStmt* alter_type_stmt);
  private:
  const ::pg_query::AlterTypeStmt& _internal_alter_type_stmt() const;
  ::pg_query::AlterTypeStmt* _internal_mutable_alter_type_stmt();
  public:
  void unsafe_arena_set_allocated_alter_type_stmt(
      ::pg_query::AlterTypeStmt* alter_type_stmt);
  ::pg_query::AlterTypeStmt* unsafe_arena_release_alter_type_stmt();

  // .pg_query.DropOwnedStmt drop_owned_stmt = 126 [json_name = "DropOwnedStmt"];
  bool has_drop_owned_stmt() const;
  private:
  bool _internal_has_drop_owned_stmt() const;
  public:
  void clear_drop_owned_stmt();
  const ::pg_query::DropOwnedStmt& drop_owned_stmt() const;
  ::pg_query::DropOwnedStmt* release_drop_owned_stmt();
  ::pg_query::DropOwnedStmt* mutable_drop_owned_stmt();
  void set_allocated_drop_owned_stmt(::pg_query::DropOwnedStmt* drop_owned_stmt);
  private:
  const ::pg_query::DropOwnedStmt& _internal_drop_owned_stmt() const;
  ::pg_query::DropOwnedStmt* _internal_mutable_drop_owned_stmt();
  public:
  void unsafe_arena_set_allocated_drop_owned_stmt(
      ::pg_query::DropOwnedStmt* drop_owned_stmt);
  ::pg_query::DropOwnedStmt* unsafe_arena_release_drop_owned_stmt();

  // .pg_query.ReassignOwnedStmt reassign_owned_stmt = 127 [json_name = "ReassignOwnedStmt"];
  bool has_reassign_owned_stmt() const;
  private:
  bool _internal_has_reassign_owned_stmt() const;
  public:
  void clear_reassign_owned_stmt();
  const ::pg_query::ReassignOwnedStmt& reassign_owned_stmt() const;
  ::pg_query::ReassignOwnedStmt* release_reassign_owned_stmt();
  ::pg_query::ReassignOwnedStmt* mutable_reassign_owned_stmt();
  void set_allocated_reassign_owned_stmt(::pg_query::ReassignOwnedStmt* reassign_owned_stmt);
  private:
  const ::pg_query::ReassignOwnedStmt& _internal_reassign_owned_stmt() const;
  ::pg_query::ReassignOwnedStmt* _internal_mutable_reassign_owned_stmt();
  public:
  void unsafe_arena_set_allocated_reassign_owned_stmt(
      ::pg_query::ReassignOwnedStmt* reassign_owned_stmt);
  ::pg_query::ReassignOwnedStmt* unsafe_arena_release_reassign_owned_stmt();

  // .pg_query.CompositeTypeStmt composite_type_stmt = 128 [json_name = "CompositeTypeStmt"];
  bool has_composite_type_stmt() const;
  private:
  bool _internal_has_composite_type_stmt() const;
  public:
  void clear_composite_type_stmt();
  const ::pg_query::CompositeTypeStmt& composite_type_stmt() const;
  ::pg_query::CompositeTypeStmt* release_composite_type_stmt();
  ::pg_query::CompositeTypeStmt* mutable_composite_type_stmt();
  void set_allocated_composite_type_stmt(::pg_query::CompositeTypeStmt* composite_type_stmt);
  private:
  const ::pg_query::CompositeTypeStmt& _internal_composite_type_stmt() const;
  ::pg_query::CompositeTypeStmt* _internal_mutable_composite_type_stmt();
  public:
  void unsafe_arena_set_allocated_composite_type_stmt(
      ::pg_query::CompositeTypeStmt* composite_type_stmt);
  ::pg_query::CompositeTypeStmt* unsafe_arena_release_composite_type_stmt();

  // .pg_query.CreateEnumStmt create_enum_stmt = 129 [json_name = "CreateEnumStmt"];
  bool has_create_enum_stmt() const;
  private:
  bool _internal_has_create_enum_stmt() const;
  public:
  void clear_create_enum_stmt();
  const ::pg_query::CreateEnumStmt& create_enum_stmt() const;
  ::pg_query::CreateEnumStmt* release_create_enum_stmt();
  ::pg_query::CreateEnumStmt* mutable_create_enum_stmt();
  void set_allocated_create_enum_stmt(::pg_query::CreateEnumStmt* create_enum_stmt);
  private:
  const ::pg_query::CreateEnumStmt& _internal_create_enum_stmt() const;
  ::pg_query::CreateEnumStmt* _internal_mutable_create_enum_stmt();
  public:
  void unsafe_arena_set_allocated_create_enum_stmt(
      ::pg_query::CreateEnumStmt* create_enum_stmt);
  ::pg_query::CreateEnumStmt* unsafe_arena_release_create_enum_stmt();

  // .pg_query.CreateRangeStmt create_range_stmt = 130 [json_name = "CreateRangeStmt"];
  bool has_create_range_stmt() const;
  private:
  bool _internal_has_create_range_stmt() const;
  public:
  void clear_create_range_stmt();
  const ::pg_query::CreateRangeStmt& create_range_stmt() const;
  ::pg_query::CreateRangeStmt* release_create_range_stmt();
  ::pg_query::CreateRangeStmt* mutable_create_range_stmt();
  void set_allocated_create_range_stmt(::pg_query::CreateRangeStmt* create_range_stmt);
  private:
  const ::pg_query::CreateRangeStmt& _internal_create_range_stmt() const;
  ::pg_query::CreateRangeStmt* _internal_mutable_create_range_stmt();
  public:
  void unsafe_arena_set_allocated_create_range_stmt(
      ::pg_query::CreateRangeStmt* create_range_stmt);
  ::pg_query::CreateRangeStmt* unsafe_arena_release_create_range_stmt();

  // .pg_query.AlterEnumStmt alter_enum_stmt = 131 [json_name = "AlterEnumStmt"];
  bool has_alter_enum_stmt() const;
  private:
  bool _internal_has_alter_enum_stmt() const;
  public:
  void clear_alter_enum_stmt();
  const ::pg_query::AlterEnumStmt& alter_enum_stmt() const;
  ::pg_query::AlterEnumStmt* release_alter_enum_stmt();
  ::pg_query::AlterEnumStmt* mutable_alter_enum_stmt();
  void set_allocated_alter_enum_stmt(::pg_query::AlterEnumStmt* alter_enum_stmt);
  private:
  const ::pg_query::AlterEnumStmt& _internal_alter_enum_stmt() const;
  ::pg_query::AlterEnumStmt* _internal_mutable_alter_enum_stmt();
  public:
  void unsafe_arena_set_allocated_alter_enum_stmt(
      ::pg_query::AlterEnumStmt* alter_enum_stmt);
  ::pg_query::AlterEnumStmt* unsafe_arena_release_alter_enum_stmt();

  // .pg_query.AlterTSDictionaryStmt alter_tsdictionary_stmt = 132 [json_name = "AlterTSDictionaryStmt"];
  bool has_alter_tsdictionary_stmt() const;
  private:
  bool _internal_has_alter_tsdictionary_stmt() const;
  public:
  void clear_alter_tsdictionary_stmt();
  const ::pg_query::AlterTSDictionaryStmt& alter_tsdictionary_stmt() const;
  ::pg_query::AlterTSDictionaryStmt* release_alter_tsdictionary_stmt();
  ::pg_query::AlterTSDictionaryStmt* mutable_alter_tsdictionary_stmt();
  void set_allocated_alter_tsdictionary_stmt(::pg_query::AlterTSDictionaryStmt* alter_tsdictionary_stmt);
  private:
  const ::pg_query::AlterTSDictionaryStmt& _internal_alter_tsdictionary_stmt() const;
  ::pg_query::AlterTSDictionaryStmt* _internal_mutable_alter_tsdictionary_stmt();
  public:
  void unsafe_arena_set_allocated_alter_tsdictionary_stmt(
      ::pg_query::AlterTSDictionaryStmt* alter_tsdictionary_stmt);
  ::pg_query::AlterTSDictionaryStmt* unsafe_arena_release_alter_tsdictionary_stmt();

  // .pg_query.AlterTSConfigurationStmt alter_tsconfiguration_stmt = 133 [json_name = "AlterTSConfigurationStmt"];
  bool has_alter_tsconfiguration_stmt() const;
  private:
  bool _internal_has_alter_tsconfiguration_stmt() const;
  public:
  void clear_alter_tsconfiguration_stmt();
  const ::pg_query::AlterTSConfigurationStmt& alter_tsconfiguration_stmt() const;
  ::pg_query::AlterTSConfigurationStmt* release_alter_tsconfiguration_stmt();
  ::pg_query::AlterTSConfigurationStmt* mutable_alter_tsconfiguration_stmt();
  void set_allocated_alter_tsconfiguration_stmt(::pg_query::AlterTSConfigurationStmt* alter_tsconfiguration_stmt);
  private:
  const ::pg_query::AlterTSConfigurationStmt& _internal_alter_tsconfiguration_stmt() const;
  ::pg_query::AlterTSConfigurationStmt* _internal_mutable_alter_tsconfiguration_stmt();
  public:
  void unsafe_arena_set_allocated_alter_tsconfiguration_stmt(
      ::pg_query::AlterTSConfigurationStmt* alter_tsconfiguration_stmt);
  ::pg_query::AlterTSConfigurationStmt* unsafe_arena_release_alter_tsconfiguration_stmt();

  // .pg_query.CreateFdwStmt create_fdw_stmt = 134 [json_name = "CreateFdwStmt"];
  bool has_create_fdw_stmt() const;
  private:
  bool _internal_has_create_fdw_stmt() const;
  public:
  void clear_create_fdw_stmt();
  const ::pg_query::CreateFdwStmt& create_fdw_stmt() const;
  ::pg_query::CreateFdwStmt* release_create_fdw_stmt();
  ::pg_query::CreateFdwStmt* mutable_create_fdw_stmt();
  void set_allocated_create_fdw_stmt(::pg_query::CreateFdwStmt* create_fdw_stmt);
  private:
  const ::pg_query::CreateFdwStmt& _internal_create_fdw_stmt() const;
  ::pg_query::CreateFdwStmt* _internal_mutable_create_fdw_stmt();
  public:
  void unsafe_arena_set_allocated_create_fdw_stmt(
      ::pg_query::CreateFdwStmt* create_fdw_stmt);
  ::pg_query::CreateFdwStmt* unsafe_arena_release_create_fdw_stmt();

  // .pg_query.AlterFdwStmt alter_fdw_stmt = 135 [json_name = "AlterFdwStmt"];
  bool has_alter_fdw_stmt() const;
  private:
  bool _internal_has_alter_fdw_stmt() const;
  public:
  void clear_alter_fdw_stmt();
  const ::pg_query::AlterFdwStmt& alter_fdw_stmt() const;
  ::pg_query::AlterFdwStmt* release_alter_fdw_stmt();
  ::pg_query::AlterFdwStmt* mutable_alter_fdw_stmt();
  void set_allocated_alter_fdw_stmt(::pg_query::AlterFdwStmt* alter_fdw_stmt);
  private:
  const ::pg_query::AlterFdwStmt& _internal_alter_fdw_stmt() const;
  ::pg_query::AlterFdwStmt* _internal_mutable_alter_fdw_stmt();
  public:
  void unsafe_arena_set_allocated_alter_fdw_stmt(
      ::pg_query::AlterFdwStmt* alter_fdw_stmt);
  ::pg_query::AlterFdwStmt* unsafe_arena_release_alter_fdw_stmt();

  // .pg_query.CreateForeignServerStmt create_foreign_server_stmt = 136 [json_name = "CreateForeignServerStmt"];
  bool has_create_foreign_server_stmt() const;
  private:
  bool _internal_has_create_foreign_server_stmt() const;
  public:
  void clear_create_foreign_server_stmt();
  const ::pg_query::CreateForeignServerStmt& create_foreign_server_stmt() const;
  ::pg_query::CreateForeignServerStmt* release_create_foreign_server_stmt();
  ::pg_query::CreateForeignServerStmt* mutable_create_foreign_server_stmt();
  void set_allocated_create_foreign_server_stmt(::pg_query::CreateForeignServerStmt* create_foreign_server_stmt);
  private:
  const ::pg_query::CreateForeignServerStmt& _internal_create_foreign_server_stmt() const;
  ::pg_query::CreateForeignServerStmt* _internal_mutable_create_foreign_server_stmt();
  public:
  void unsafe_arena_set_allocated_create_foreign_server_stmt(
      ::pg_query::CreateForeignServerStmt* create_foreign_server_stmt);
  ::pg_query::CreateForeignServerStmt* unsafe_arena_release_create_foreign_server_stmt();

  // .pg_query.AlterForeignServerStmt alter_foreign_server_stmt = 137 [json_name = "AlterForeignServerStmt"];
  bool has_alter_foreign_server_stmt() const;
  private:
  bool _internal_has_alter_foreign_server_stmt() const;
  public:
  void clear_alter_foreign_server_stmt();
  const ::pg_query::AlterForeignServerStmt& alter_foreign_server_stmt() const;
  ::pg_query::AlterForeignServerStmt* release_alter_foreign_server_stmt();
  ::pg_query::AlterForeignServerStmt* mutable_alter_foreign_server_stmt();
  void set_allocated_alter_foreign_server_stmt(::pg_query::AlterForeignServerStmt* alter_foreign_server_stmt);
  private:
  const ::pg_query::AlterForeignServerStmt& _internal_alter_foreign_server_stmt() const;
  ::pg_query::AlterForeignServerStmt* _internal_mutable_alter_foreign_server_stmt();
  public:
  void unsafe_arena_set_allocated_alter_foreign_server_stmt(
      ::pg_query::AlterForeignServerStmt* alter_foreign_server_stmt);
  ::pg_query::AlterForeignServerStmt* unsafe_arena_release_alter_foreign_server_stmt();

  // .pg_query.CreateUserMappingStmt create_user_mapping_stmt = 138 [json_name = "CreateUserMappingStmt"];
  bool has_create_user_mapping_stmt() const;
  private:
  bool _internal_has_create_user_mapping_stmt() const;
  public:
  void clear_create_user_mapping_stmt();
  const ::pg_query::CreateUserMappingStmt& create_user_mapping_stmt() const;
  ::pg_query::CreateUserMappingStmt* release_create_user_mapping_stmt();
  ::pg_query::CreateUserMappingStmt* mutable_create_user_mapping_stmt();
  void set_allocated_create_user_mapping_stmt(::pg_query::CreateUserMappingStmt* create_user_mapping_stmt);
  private:
  const ::pg_query::CreateUserMappingStmt& _internal_create_user_mapping_stmt() const;
  ::pg_query::CreateUserMappingStmt* _internal_mutable_create_user_mapping_stmt();
  public:
  void unsafe_arena_set_allocated_create_user_mapping_stmt(
      ::pg_query::CreateUserMappingStmt* create_user_mapping_stmt);
  ::pg_query::CreateUserMappingStmt* unsafe_arena_release_create_user_mapping_stmt();

  // .pg_query.AlterUserMappingStmt alter_user_mapping_stmt = 139 [json_name = "AlterUserMappingStmt"];
  bool has_alter_user_mapping_stmt() const;
  private:
  bool _internal_has_alter_user_mapping_stmt() const;
  public:
  void clear_alter_user_mapping_stmt();
  const ::pg_query::AlterUserMappingStmt& alter_user_mapping_stmt() const;
  ::pg_query::AlterUserMappingStmt* release_alter_user_mapping_stmt();
  ::pg_query::AlterUserMappingStmt* mutable_alter_user_mapping_stmt();
  void set_allocated_alter_user_mapping_stmt(::pg_query::AlterUserMappingStmt* alter_user_mapping_stmt);
  private:
  const ::pg_query::AlterUserMappingStmt& _internal_alter_user_mapping_stmt() const;
  ::pg_query::AlterUserMappingStmt* _internal_mutable_alter_user_mapping_stmt();
  public:
  void unsafe_arena_set_allocated_alter_user_mapping_stmt(
      ::pg_query::AlterUserMappingStmt* alter_user_mapping_stmt);
  ::pg_query::AlterUserMappingStmt* unsafe_arena_release_alter_user_mapping_stmt();

  // .pg_query.DropUserMappingStmt drop_user_mapping_stmt = 140 [json_name = "DropUserMappingStmt"];
  bool has_drop_user_mapping_stmt() const;
  private:
  bool _internal_has_drop_user_mapping_stmt() const;
  public:
  void clear_drop_user_mapping_stmt();
  const ::pg_query::DropUserMappingStmt& drop_user_mapping_stmt() const;
  ::pg_query::DropUserMappingStmt* release_drop_user_mapping_stmt();
  ::pg_query::DropUserMappingStmt* mutable_drop_user_mapping_stmt();
  void set_allocated_drop_user_mapping_stmt(::pg_query::DropUserMappingStmt* drop_user_mapping_stmt);
  private:
  const ::pg_query::DropUserMappingStmt& _internal_drop_user_mapping_stmt() const;
  ::pg_query::DropUserMappingStmt* _internal_mutable_drop_user_mapping_stmt();
  public:
  void unsafe_arena_set_allocated_drop_user_mapping_stmt(
      ::pg_query::DropUserMappingStmt* drop_user_mapping_stmt);
  ::pg_query::DropUserMappingStmt* unsafe_arena_release_drop_user_mapping_stmt();

  // .pg_query.AlterTableSpaceOptionsStmt alter_table_space_options_stmt = 141 [json_name = "AlterTableSpaceOptionsStmt"];
  bool has_alter_table_space_options_stmt() const;
  private:
  bool _internal_has_alter_table_space_options_stmt() const;
  public:
  void clear_alter_table_space_options_stmt();
  const ::pg_query::AlterTableSpaceOptionsStmt& alter_table_space_options_stmt() const;
  ::pg_query::AlterTableSpaceOptionsStmt* release_alter_table_space_options_stmt();
  ::pg_query::AlterTableSpaceOptionsStmt* mutable_alter_table_space_options_stmt();
  void set_allocated_alter_table_space_options_stmt(::pg_query::AlterTableSpaceOptionsStmt* alter_table_space_options_stmt);
  private:
  const ::pg_query::AlterTableSpaceOptionsStmt& _internal_alter_table_space_options_stmt() const;
  ::pg_query::AlterTableSpaceOptionsStmt* _internal_mutable_alter_table_space_options_stmt();
  public:
  void unsafe_arena_set_allocated_alter_table_space_options_stmt(
      ::pg_query::AlterTableSpaceOptionsStmt* alter_table_space_options_stmt);
  ::pg_query::AlterTableSpaceOptionsStmt* unsafe_arena_release_alter_table_space_options_stmt();

  // .pg_query.AlterTableMoveAllStmt alter_table_move_all_stmt = 142 [json_name = "AlterTableMoveAllStmt"];
  bool has_alter_table_move_all_stmt() const;
  private:
  bool _internal_has_alter_table_move_all_stmt() const;
  public:
  void clear_alter_table_move_all_stmt();
  const ::pg_query::AlterTableMoveAllStmt& alter_table_move_all_stmt() const;
  ::pg_query::AlterTableMoveAllStmt* release_alter_table_move_all_stmt();
  ::pg_query::AlterTableMoveAllStmt* mutable_alter_table_move_all_stmt();
  void set_allocated_alter_table_move_all_stmt(::pg_query::AlterTableMoveAllStmt* alter_table_move_all_stmt);
  private:
  const ::pg_query::AlterTableMoveAllStmt& _internal_alter_table_move_all_stmt() const;
  ::pg_query::AlterTableMoveAllStmt* _internal_mutable_alter_table_move_all_stmt();
  public:
  void unsafe_arena_set_allocated_alter_table_move_all_stmt(
      ::pg_query::AlterTableMoveAllStmt* alter_table_move_all_stmt);
  ::pg_query::AlterTableMoveAllStmt* unsafe_arena_release_alter_table_move_all_stmt();

  // .pg_query.SecLabelStmt sec_label_stmt = 143 [json_name = "SecLabelStmt"];
  bool has_sec_label_stmt() const;
  private:
  bool _internal_has_sec_label_stmt() const;
  public:
  void clear_sec_label_stmt();
  const ::pg_query::SecLabelStmt& sec_label_stmt() const;
  ::pg_query::SecLabelStmt* release_sec_label_stmt();
  ::pg_query::SecLabelStmt* mutable_sec_label_stmt();
  void set_allocated_sec_label_stmt(::pg_query::SecLabelStmt* sec_label_stmt);
  private:
  const ::pg_query::SecLabelStmt& _internal_sec_label_stmt() const;
  ::pg_query::SecLabelStmt* _internal_mutable_sec_label_stmt();
  public:
  void unsafe_arena_set_allocated_sec_label_stmt(
      ::pg_query::SecLabelStmt* sec_label_stmt);
  ::pg_query::SecLabelStmt* unsafe_arena_release_sec_label_stmt();

  // .pg_query.CreateForeignTableStmt create_foreign_table_stmt = 144 [json_name = "CreateForeignTableStmt"];
  bool has_create_foreign_table_stmt() const;
  private:
  bool _internal_has_create_foreign_table_stmt() const;
  public:
  void clear_create_foreign_table_stmt();
  const ::pg_query::CreateForeignTableStmt& create_foreign_table_stmt() const;
  ::pg_query::CreateForeignTableStmt* release_create_foreign_table_stmt();
  ::pg_query::CreateForeignTableStmt* mutable_create_foreign_table_stmt();
  void set_allocated_create_foreign_table_stmt(::pg_query::CreateForeignTableStmt* create_foreign_table_stmt);
  private:
  const ::pg_query::CreateForeignTableStmt& _internal_create_foreign_table_stmt() const;
  ::pg_query::CreateForeignTableStmt* _internal_mutable_create_foreign_table_stmt();
  public:
  void unsafe_arena_set_allocated_create_foreign_table_stmt(
      ::pg_query::CreateForeignTableStmt* create_foreign_table_stmt);
  ::pg_query::CreateForeignTableStmt* unsafe_arena_release_create_foreign_table_stmt();

  // .pg_query.ImportForeignSchemaStmt import_foreign_schema_stmt = 145 [json_name = "ImportForeignSchemaStmt"];
  bool has_import_foreign_schema_stmt() const;
  private:
  bool _internal_has_import_foreign_schema_stmt() const;
  public:
  void clear_import_foreign_schema_stmt();
  const ::pg_query::ImportForeignSchemaStmt& import_foreign_schema_stmt() const;
  ::pg_query::ImportForeignSchemaStmt* release_import_foreign_schema_stmt();
  ::pg_query::ImportForeignSchemaStmt* mutable_import_foreign_schema_stmt();
  void set_allocated_import_foreign_schema_stmt(::pg_query::ImportForeignSchemaStmt* import_foreign_schema_stmt);
  private:
  const ::pg_query::ImportForeignSchemaStmt& _internal_import_foreign_schema_stmt() const;
  ::pg_query::ImportForeignSchemaStmt* _internal_mutable_import_foreign_schema_stmt();
  public:
  void unsafe_arena_set_allocated_import_foreign_schema_stmt(
      ::pg_query::ImportForeignSchemaStmt* import_foreign_schema_stmt);
  ::pg_query::ImportForeignSchemaStmt* unsafe_arena_release_import_foreign_schema_stmt();

  // .pg_query.CreateExtensionStmt create_extension_stmt = 146 [json_name = "CreateExtensionStmt"];
  bool has_create_extension_stmt() const;
  private:
  bool _internal_has_create_extension_stmt() const;
  public:
  void clear_create_extension_stmt();
  const ::pg_query::CreateExtensionStmt& create_extension_stmt() const;
  ::pg_query::CreateExtensionStmt* release_create_extension_stmt();
  ::pg_query::CreateExtensionStmt* mutable_create_extension_stmt();
  void set_allocated_create_extension_stmt(::pg_query::CreateExtensionStmt* create_extension_stmt);
  private:
  const ::pg_query::CreateExtensionStmt& _internal_create_extension_stmt() const;
  ::pg_query::CreateExtensionStmt* _internal_mutable_create_extension_stmt();
  public:
  void unsafe_arena_set_allocated_create_extension_stmt(
      ::pg_query::CreateExtensionStmt* create_extension_stmt);
  ::pg_query::CreateExtensionStmt* unsafe_arena_release_create_extension_stmt();

  // .pg_query.AlterExtensionStmt alter_extension_stmt = 147 [json_name = "AlterExtensionStmt"];
  bool has_alter_extension_stmt() const;
  private:
  bool _internal_has_alter_extension_stmt() const;
  public:
  void clear_alter_extension_stmt();
  const ::pg_query::AlterExtensionStmt& alter_extension_stmt() const;
  ::pg_query::AlterExtensionStmt* release_alter_extension_stmt();
  ::pg_query::AlterExtensionStmt* mutable_alter_extension_stmt();
  void set_allocated_alter_extension_stmt(::pg_query::AlterExtensionStmt* alter_extension_stmt);
  private:
  const ::pg_query::AlterExtensionStmt& _internal_alter_extension_stmt() const;
  ::pg_query::AlterExtensionStmt* _internal_mutable_alter_extension_stmt();
  public:
  void unsafe_arena_set_allocated_alter_extension_stmt(
      ::pg_query::AlterExtensionStmt* alter_extension_stmt);
  ::pg_query::AlterExtensionStmt* unsafe_arena_release_alter_extension_stmt();

  // .pg_query.AlterExtensionContentsStmt alter_extension_contents_stmt = 148 [json_name = "AlterExtensionContentsStmt"];
  bool has_alter_extension_contents_stmt() const;
  private:
  bool _internal_has_alter_extension_contents_stmt() const;
  public:
  void clear_alter_extension_contents_stmt();
  const ::pg_query::AlterExtensionContentsStmt& alter_extension_contents_stmt() const;
  ::pg_query::AlterExtensionContentsStmt* release_alter_extension_contents_stmt();
  ::pg_query::AlterExtensionContentsStmt* mutable_alter_extension_contents_stmt();
  void set_allocated_alter_extension_contents_stmt(::pg_query::AlterExtensionContentsStmt* alter_extension_contents_stmt);
  private:
  const ::pg_query::AlterExtensionContentsStmt& _internal_alter_extension_contents_stmt() const;
  ::pg_query::AlterExtensionContentsStmt* _internal_mutable_alter_extension_contents_stmt();
  public:
  void unsafe_arena_set_allocated_alter_extension_contents_stmt(
      ::pg_query::AlterExtensionContentsStmt* alter_extension_contents_stmt);
  ::pg_query::AlterExtensionContentsStmt* unsafe_arena_release_alter_extension_contents_stmt();

  // .pg_query.CreateEventTrigStmt create_event_trig_stmt = 149 [json_name = "CreateEventTrigStmt"];
  bool has_create_event_trig_stmt() const;
  private:
  bool _internal_has_create_event_trig_stmt() const;
  public:
  void clear_create_event_trig_stmt();
  const ::pg_query::CreateEventTrigStmt& create_event_trig_stmt() const;
  ::pg_query::CreateEventTrigStmt* release_create_event_trig_stmt();
  ::pg_query::CreateEventTrigStmt* mutable_create_event_trig_stmt();
  void set_allocated_create_event_trig_stmt(::pg_query::CreateEventTrigStmt* create_event_trig_stmt);
  private:
  const ::pg_query::CreateEventTrigStmt& _internal_create_event_trig_stmt() const;
  ::pg_query::CreateEventTrigStmt* _internal_mutable_create_event_trig_stmt();
  public:
  void unsafe_arena_set_allocated_create_event_trig_stmt(
      ::pg_query::CreateEventTrigStmt* create_event_trig_stmt);
  ::pg_query::CreateEventTrigStmt* unsafe_arena_release_create_event_trig_stmt();

  // .pg_query.AlterEventTrigStmt alter_event_trig_stmt = 150 [json_name = "AlterEventTrigStmt"];
  bool has_alter_event_trig_stmt() const;
  private:
  bool _internal_has_alter_event_trig_stmt() const;
  public:
  void clear_alter_event_trig_stmt();
  const ::pg_query::AlterEventTrigStmt& alter_event_trig_stmt() const;
  ::pg_query::AlterEventTrigStmt* release_alter_event_trig_stmt();
  ::pg_query::AlterEventTrigStmt* mutable_alter_event_trig_stmt();
  void set_allocated_alter_event_trig_stmt(::pg_query::AlterEventTrigStmt* alter_event_trig_stmt);
  private:
  const ::pg_query::AlterEventTrigStmt& _internal_alter_event_trig_stmt() const;
  ::pg_query::AlterEventTrigStmt* _internal_mutable_alter_event_trig_stmt();
  public:
  void unsafe_arena_set_allocated_alter_event_trig_stmt(
      ::pg_query::AlterEventTrigStmt* alter_event_trig_stmt);
  ::pg_query::AlterEventTrigStmt* unsafe_arena_release_alter_event_trig_stmt();

  // .pg_query.RefreshMatViewStmt refresh_mat_view_stmt = 151 [json_name = "RefreshMatViewStmt"];
  bool has_refresh_mat_view_stmt() const;
  private:
  bool _internal_has_refresh_mat_view_stmt() const;
  public:
  void clear_refresh_mat_view_stmt();
  const ::pg_query::RefreshMatViewStmt& refresh_mat_view_stmt() const;
  ::pg_query::RefreshMatViewStmt* release_refresh_mat_view_stmt();
  ::pg_query::RefreshMatViewStmt* mutable_refresh_mat_view_stmt();
  void set_allocated_refresh_mat_view_stmt(::pg_query::RefreshMatViewStmt* refresh_mat_view_stmt);
  private:
  const ::pg_query::RefreshMatViewStmt& _internal_refresh_mat_view_stmt() const;
  ::pg_query::RefreshMatViewStmt* _internal_mutable_refresh_mat_view_stmt();
  public:
  void unsafe_arena_set_allocated_refresh_mat_view_stmt(
      ::pg_query::RefreshMatViewStmt* refresh_mat_view_stmt);
  ::pg_query::RefreshMatViewStmt* unsafe_arena_release_refresh_mat_view_stmt();

  // .pg_query.ReplicaIdentityStmt replica_identity_stmt = 152 [json_name = "ReplicaIdentityStmt"];
  bool has_replica_identity_stmt() const;
  private:
  bool _internal_has_replica_identity_stmt() const;
  public:
  void clear_replica_identity_stmt();
  const ::pg_query::ReplicaIdentityStmt& replica_identity_stmt() const;
  ::pg_query::ReplicaIdentityStmt* release_replica_identity_stmt();
  ::pg_query::ReplicaIdentityStmt* mutable_replica_identity_stmt();
  void set_allocated_replica_identity_stmt(::pg_query::ReplicaIdentityStmt* replica_identity_stmt);
  private:
  const ::pg_query::ReplicaIdentityStmt& _internal_replica_identity_stmt() const;
  ::pg_query::ReplicaIdentityStmt* _internal_mutable_replica_identity_stmt();
  public:
  void unsafe_arena_set_allocated_replica_identity_stmt(
      ::pg_query::ReplicaIdentityStmt* replica_identity_stmt);
  ::pg_query::ReplicaIdentityStmt* unsafe_arena_release_replica_identity_stmt();

  // .pg_query.AlterSystemStmt alter_system_stmt = 153 [json_name = "AlterSystemStmt"];
  bool has_alter_system_stmt() const;
  private:
  bool _internal_has_alter_system_stmt() const;
  public:
  void clear_alter_system_stmt();
  const ::pg_query::AlterSystemStmt& alter_system_stmt() const;
  ::pg_query::AlterSystemStmt* release_alter_system_stmt();
  ::pg_query::AlterSystemStmt* mutable_alter_system_stmt();
  void set_allocated_alter_system_stmt(::pg_query::AlterSystemStmt* alter_system_stmt);
  private:
  const ::pg_query::AlterSystemStmt& _internal_alter_system_stmt() const;
  ::pg_query::AlterSystemStmt* _internal_mutable_alter_system_stmt();
  public:
  void unsafe_arena_set_allocated_alter_system_stmt(
      ::pg_query::AlterSystemStmt* alter_system_stmt);
  ::pg_query::AlterSystemStmt* unsafe_arena_release_alter_system_stmt();

  // .pg_query.CreatePolicyStmt create_policy_stmt = 154 [json_name = "CreatePolicyStmt"];
  bool has_create_policy_stmt() const;
  private:
  bool _internal_has_create_policy_stmt() const;
  public:
  void clear_create_policy_stmt();
  const ::pg_query::CreatePolicyStmt& create_policy_stmt() const;
  ::pg_query::CreatePolicyStmt* release_create_policy_stmt();
  ::pg_query::CreatePolicyStmt* mutable_create_policy_stmt();
  void set_allocated_create_policy_stmt(::pg_query::CreatePolicyStmt* create_policy_stmt);
  private:
  const ::pg_query::CreatePolicyStmt& _internal_create_policy_stmt() const;
  ::pg_query::CreatePolicyStmt* _internal_mutable_create_policy_stmt();
  public:
  void unsafe_arena_set_allocated_create_policy_stmt(
      ::pg_query::CreatePolicyStmt* create_policy_stmt);
  ::pg_query::CreatePolicyStmt* unsafe_arena_release_create_policy_stmt();

  // .pg_query.AlterPolicyStmt alter_policy_stmt = 155 [json_name = "AlterPolicyStmt"];
  bool has_alter_policy_stmt() const;
  private:
  bool _internal_has_alter_policy_stmt() const;
  public:
  void clear_alter_policy_stmt();
  const ::pg_query::AlterPolicyStmt& alter_policy_stmt() const;
  ::pg_query::AlterPolicyStmt* release_alter_policy_stmt();
  ::pg_query::AlterPolicyStmt* mutable_alter_policy_stmt();
  void set_allocated_alter_policy_stmt(::pg_query::AlterPolicyStmt* alter_policy_stmt);
  private:
  const ::pg_query::AlterPolicyStmt& _internal_alter_policy_stmt() const;
  ::pg_query::AlterPolicyStmt* _internal_mutable_alter_policy_stmt();
  public:
  void unsafe_arena_set_allocated_alter_policy_stmt(
      ::pg_query::AlterPolicyStmt* alter_policy_stmt);
  ::pg_query::AlterPolicyStmt* unsafe_arena_release_alter_policy_stmt();

  // .pg_query.CreateTransformStmt create_transform_stmt = 156 [json_name = "CreateTransformStmt"];
  bool has_create_transform_stmt() const;
  private:
  bool _internal_has_create_transform_stmt() const;
  public:
  void clear_create_transform_stmt();
  const ::pg_query::CreateTransformStmt& create_transform_stmt() const;
  ::pg_query::CreateTransformStmt* release_create_transform_stmt();
  ::pg_query::CreateTransformStmt* mutable_create_transform_stmt();
  void set_allocated_create_transform_stmt(::pg_query::CreateTransformStmt* create_transform_stmt);
  private:
  const ::pg_query::CreateTransformStmt& _internal_create_transform_stmt() const;
  ::pg_query::CreateTransformStmt* _internal_mutable_create_transform_stmt();
  public:
  void unsafe_arena_set_allocated_create_transform_stmt(
      ::pg_query::CreateTransformStmt* create_transform_stmt);
  ::pg_query::CreateTransformStmt* unsafe_arena_release_create_transform_stmt();

  // .pg_query.CreateAmStmt create_am_stmt = 157 [json_name = "CreateAmStmt"];
  bool has_create_am_stmt() const;
  private:
  bool _internal_has_create_am_stmt() const;
  public:
  void clear_create_am_stmt();
  const ::pg_query::CreateAmStmt& create_am_stmt() const;
  ::pg_query::CreateAmStmt* release_create_am_stmt();
  ::pg_query::CreateAmStmt* mutable_create_am_stmt();
  void set_allocated_create_am_stmt(::pg_query::CreateAmStmt* create_am_stmt);
  private:
  const ::pg_query::CreateAmStmt& _internal_create_am_stmt() const;
  ::pg_query::CreateAmStmt* _internal_mutable_create_am_stmt();
  public:
  void unsafe_arena_set_allocated_create_am_stmt(
      ::pg_query::CreateAmStmt* create_am_stmt);
  ::pg_query::CreateAmStmt* unsafe_arena_release_create_am_stmt();

  // .pg_query.CreatePublicationStmt create_publication_stmt = 158 [json_name = "CreatePublicationStmt"];
  bool has_create_publication_stmt() const;
  private:
  bool _internal_has_create_publication_stmt() const;
  public:
  void clear_create_publication_stmt();
  const ::pg_query::CreatePublicationStmt& create_publication_stmt() const;
  ::pg_query::CreatePublicationStmt* release_create_publication_stmt();
  ::pg_query::CreatePublicationStmt* mutable_create_publication_stmt();
  void set_allocated_create_publication_stmt(::pg_query::CreatePublicationStmt* create_publication_stmt);
  private:
  const ::pg_query::CreatePublicationStmt& _internal_create_publication_stmt() const;
  ::pg_query::CreatePublicationStmt* _internal_mutable_create_publication_stmt();
  public:
  void unsafe_arena_set_allocated_create_publication_stmt(
      ::pg_query::CreatePublicationStmt* create_publication_stmt);
  ::pg_query::CreatePublicationStmt* unsafe_arena_release_create_publication_stmt();

  // .pg_query.AlterPublicationStmt alter_publication_stmt = 159 [json_name = "AlterPublicationStmt"];
  bool has_alter_publication_stmt() const;
  private:
  bool _internal_has_alter_publication_stmt() const;
  public:
  void clear_alter_publication_stmt();
  const ::pg_query::AlterPublicationStmt& alter_publication_stmt() const;
  ::pg_query::AlterPublicationStmt* release_alter_publication_stmt();
  ::pg_query::AlterPublicationStmt* mutable_alter_publication_stmt();
  void set_allocated_alter_publication_stmt(::pg_query::AlterPublicationStmt* alter_publication_stmt);
  private:
  const ::pg_query::AlterPublicationStmt& _internal_alter_publication_stmt() const;
  ::pg_query::AlterPublicationStmt* _internal_mutable_alter_publication_stmt();
  public:
  void unsafe_arena_set_allocated_alter_publication_stmt(
      ::pg_query::AlterPublicationStmt* alter_publication_stmt);
  ::pg_query::AlterPublicationStmt* unsafe_arena_release_alter_publication_stmt();

  // .pg_query.CreateSubscriptionStmt create_subscription_stmt = 160 [json_name = "CreateSubscriptionStmt"];
  bool has_create_subscription_stmt() const;
  private:
  bool _internal_has_create_subscription_stmt() const;
  public:
  void clear_create_subscription_stmt();
  const ::pg_query::CreateSubscriptionStmt& create_subscription_stmt() const;
  ::pg_query::CreateSubscriptionStmt* release_create_subscription_stmt();
  ::pg_query::CreateSubscriptionStmt* mutable_create_subscription_stmt();
  void set_allocated_create_subscription_stmt(::pg_query::CreateSubscriptionStmt* create_subscription_stmt);
  private:
  const ::pg_query::CreateSubscriptionStmt& _internal_create_subscription_stmt() const;
  ::pg_query::CreateSubscriptionStmt* _internal_mutable_create_subscription_stmt();
  public:
  void unsafe_arena_set_allocated_create_subscription_stmt(
      ::pg_query::CreateSubscriptionStmt* create_subscription_stmt);
  ::pg_query::CreateSubscriptionStmt* unsafe_arena_release_create_subscription_stmt();

  // .pg_query.AlterSubscriptionStmt alter_subscription_stmt = 161 [json_name = "AlterSubscriptionStmt"];
  bool has_alter_subscription_stmt() const;
  private:
  bool _internal_has_alter_subscription_stmt() const;
  public:
  void clear_alter_subscription_stmt();
  const ::pg_query::AlterSubscriptionStmt& alter_subscription_stmt() const;
  ::pg_query::AlterSubscriptionStmt* release_alter_subscription_stmt();
  ::pg_query::AlterSubscriptionStmt* mutable_alter_subscription_stmt();
  void set_allocated_alter_subscription_stmt(::pg_query::AlterSubscriptionStmt* alter_subscription_stmt);
  private:
  const ::pg_query::AlterSubscriptionStmt& _internal_alter_subscription_stmt() const;
  ::pg_query::AlterSubscriptionStmt* _internal_mutable_alter_subscription_stmt();
  public:
  void unsafe_arena_set_allocated_alter_subscription_stmt(
      ::pg_query::AlterSubscriptionStmt* alter_subscription_stmt);
  ::pg_query::AlterSubscriptionStmt* unsafe_arena_release_alter_subscription_stmt();

  // .pg_query.DropSubscriptionStmt drop_subscription_stmt = 162 [json_name = "DropSubscriptionStmt"];
  bool has_drop_subscription_stmt() const;
  private:
  bool _internal_has_drop_subscription_stmt() const;
  public:
  void clear_drop_subscription_stmt();
  const ::pg_query::DropSubscriptionStmt& drop_subscription_stmt() const;
  ::pg_query::DropSubscriptionStmt* release_drop_subscription_stmt();
  ::pg_query::DropSubscriptionStmt* mutable_drop_subscription_stmt();
  void set_allocated_drop_subscription_stmt(::pg_query::DropSubscriptionStmt* drop_subscription_stmt);
  private:
  const ::pg_query::DropSubscriptionStmt& _internal_drop_subscription_stmt() const;
  ::pg_query::DropSubscriptionStmt* _internal_mutable_drop_subscription_stmt();
  public:
  void unsafe_arena_set_allocated_drop_subscription_stmt(
      ::pg_query::DropSubscriptionStmt* drop_subscription_stmt);
  ::pg_query::DropSubscriptionStmt* unsafe_arena_release_drop_subscription_stmt();

  // .pg_query.CreateStatsStmt create_stats_stmt = 163 [json_name = "CreateStatsStmt"];
  bool has_create_stats_stmt() const;
  private:
  bool _internal_has_create_stats_stmt() const;
  public:
  void clear_create_stats_stmt();
  const ::pg_query::CreateStatsStmt& create_stats_stmt() const;
  ::pg_query::CreateStatsStmt* release_create_stats_stmt();
  ::pg_query::CreateStatsStmt* mutable_create_stats_stmt();
  void set_allocated_create_stats_stmt(::pg_query::CreateStatsStmt* create_stats_stmt);
  private:
  const ::pg_query::CreateStatsStmt& _internal_create_stats_stmt() const;
  ::pg_query::CreateStatsStmt* _internal_mutable_create_stats_stmt();
  public:
  void unsafe_arena_set_allocated_create_stats_stmt(
      ::pg_query::CreateStatsStmt* create_stats_stmt);
  ::pg_query::CreateStatsStmt* unsafe_arena_release_create_stats_stmt();

  // .pg_query.AlterCollationStmt alter_collation_stmt = 164 [json_name = "AlterCollationStmt"];
  bool has_alter_collation_stmt() const;
  private:
  bool _internal_has_alter_collation_stmt() const;
  public:
  void clear_alter_collation_stmt();
  const ::pg_query::AlterCollationStmt& alter_collation_stmt() const;
  ::pg_query::AlterCollationStmt* release_alter_collation_stmt();
  ::pg_query::AlterCollationStmt* mutable_alter_collation_stmt();
  void set_allocated_alter_collation_stmt(::pg_query::AlterCollationStmt* alter_collation_stmt);
  private:
  const ::pg_query::AlterCollationStmt& _internal_alter_collation_stmt() const;
  ::pg_query::AlterCollationStmt* _internal_mutable_alter_collation_stmt();
  public:
  void unsafe_arena_set_allocated_alter_collation_stmt(
      ::pg_query::AlterCollationStmt* alter_collation_stmt);
  ::pg_query::AlterCollationStmt* unsafe_arena_release_alter_collation_stmt();

  // .pg_query.CallStmt call_stmt = 165 [json_name = "CallStmt"];
  bool has_call_stmt() const;
  private:
  bool _internal_has_call_stmt() const;
  public:
  void clear_call_stmt();
  const ::pg_query::CallStmt& call_stmt() const;
  ::pg_query::CallStmt* release_call_stmt();
  ::pg_query::CallStmt* mutable_call_stmt();
  void set_allocated_call_stmt(::pg_query::CallStmt* call_stmt);
  private:
  const ::pg_query::CallStmt& _internal_call_stmt() const;
  ::pg_query::CallStmt* _internal_mutable_call_stmt();
  public:
  void unsafe_arena_set_allocated_call_stmt(
      ::pg_query::CallStmt* call_stmt);
  ::pg_query::CallStmt* unsafe_arena_release_call_stmt();

  // .pg_query.AlterStatsStmt alter_stats_stmt = 166 [json_name = "AlterStatsStmt"];
  bool has_alter_stats_stmt() const;
  private:
  bool _internal_has_alter_stats_stmt() const;
  public:
  void clear_alter_stats_stmt();
  const ::pg_query::AlterStatsStmt& alter_stats_stmt() const;
  ::pg_query::AlterStatsStmt* release_alter_stats_stmt();
  ::pg_query::AlterStatsStmt* mutable_alter_stats_stmt();
  void set_allocated_alter_stats_stmt(::pg_query::AlterStatsStmt* alter_stats_stmt);
  private:
  const ::pg_query::AlterStatsStmt& _internal_alter_stats_stmt() const;
  ::pg_query::AlterStatsStmt* _internal_mutable_alter_stats_stmt();
  public:
  void unsafe_arena_set_allocated_alter_stats_stmt(
      ::pg_query::AlterStatsStmt* alter_stats_stmt);
  ::pg_query::AlterStatsStmt* unsafe_arena_release_alter_stats_stmt();

  // .pg_query.A_Expr a_expr = 167 [json_name = "A_Expr"];
  bool has_a_expr() const;
  private:
  bool _internal_has_a_expr() const;
  public:
  void clear_a_expr();
  const ::pg_query::A_Expr& a_expr() const;
  ::pg_query::A_Expr* release_a_expr();
  ::pg_query::A_Expr* mutable_a_expr();
  void set_allocated_a_expr(::pg_query::A_Expr* a_expr);
  private:
  const ::pg_query::A_Expr& _internal_a_expr() const;
  ::pg_query::A_Expr* _internal_mutable_a_expr();
  public:
  void unsafe_arena_set_allocated_a_expr(
      ::pg_query::A_Expr* a_expr);
  ::pg_query::A_Expr* unsafe_arena_release_a_expr();

  // .pg_query.ColumnRef column_ref = 168 [json_name = "ColumnRef"];
  bool has_column_ref() const;
  private:
  bool _internal_has_column_ref() const;
  public:
  void clear_column_ref();
  const ::pg_query::ColumnRef& column_ref() const;
  ::pg_query::ColumnRef* release_column_ref();
  ::pg_query::ColumnRef* mutable_column_ref();
  void set_allocated_column_ref(::pg_query::ColumnRef* column_ref);
  private:
  const ::pg_query::ColumnRef& _internal_column_ref() const;
  ::pg_query::ColumnRef* _internal_mutable_column_ref();
  public:
  void unsafe_arena_set_allocated_column_ref(
      ::pg_query::ColumnRef* column_ref);
  ::pg_query::ColumnRef* unsafe_arena_release_column_ref();

  // .pg_query.ParamRef param_ref = 169 [json_name = "ParamRef"];
  bool has_param_ref() const;
  private:
  bool _internal_has_param_ref() const;
  public:
  void clear_param_ref();
  const ::pg_query::ParamRef& param_ref() const;
  ::pg_query::ParamRef* release_param_ref();
  ::pg_query::ParamRef* mutable_param_ref();
  void set_allocated_param_ref(::pg_query::ParamRef* param_ref);
  private:
  const ::pg_query::ParamRef& _internal_param_ref() const;
  ::pg_query::ParamRef* _internal_mutable_param_ref();
  public:
  void unsafe_arena_set_allocated_param_ref(
      ::pg_query::ParamRef* param_ref);
  ::pg_query::ParamRef* unsafe_arena_release_param_ref();

  // .pg_query.A_Const a_const = 170 [json_name = "A_Const"];
  bool has_a_const() const;
  private:
  bool _internal_has_a_const() const;
  public:
  void clear_a_const();
  const ::pg_query::A_Const& a_const() const;
  ::pg_query::A_Const* release_a_const();
  ::pg_query::A_Const* mutable_a_const();
  void set_allocated_a_const(::pg_query::A_Const* a_const);
  private:
  const ::pg_query::A_Const& _internal_a_const() const;
  ::pg_query::A_Const* _internal_mutable_a_const();
  public:
  void unsafe_arena_set_allocated_a_const(
      ::pg_query::A_Const* a_const);
  ::pg_query::A_Const* unsafe_arena_release_a_const();

  // .pg_query.FuncCall func_call = 171 [json_name = "FuncCall"];
  bool has_func_call() const;
  private:
  bool _internal_has_func_call() const;
  public:
  void clear_func_call();
  const ::pg_query::FuncCall& func_call() const;
  ::pg_query::FuncCall* release_func_call();
  ::pg_query::FuncCall* mutable_func_call();
  void set_allocated_func_call(::pg_query::FuncCall* func_call);
  private:
  const ::pg_query::FuncCall& _internal_func_call() const;
  ::pg_query::FuncCall* _internal_mutable_func_call();
  public:
  void unsafe_arena_set_allocated_func_call(
      ::pg_query::FuncCall* func_call);
  ::pg_query::FuncCall* unsafe_arena_release_func_call();

  // .pg_query.A_Star a_star = 172 [json_name = "A_Star"];
  bool has_a_star() const;
  private:
  bool _internal_has_a_star() const;
  public:
  void clear_a_star();
  const ::pg_query::A_Star& a_star() const;
  ::pg_query::A_Star* release_a_star();
  ::pg_query::A_Star* mutable_a_star();
  void set_allocated_a_star(::pg_query::A_Star* a_star);
  private:
  const ::pg_query::A_Star& _internal_a_star() const;
  ::pg_query::A_Star* _internal_mutable_a_star();
  public:
  void unsafe_arena_set_allocated_a_star(
      ::pg_query::A_Star* a_star);
  ::pg_query::A_Star* unsafe_arena_release_a_star();

  // .pg_query.A_Indices a_indices = 173 [json_name = "A_Indices"];
  bool has_a_indices() const;
  private:
  bool _internal_has_a_indices() const;
  public:
  void clear_a_indices();
  const ::pg_query::A_Indices& a_indices() const;
  ::pg_query::A_Indices* release_a_indices();
  ::pg_query::A_Indices* mutable_a_indices();
  void set_allocated_a_indices(::pg_query::A_Indices* a_indices);
  private:
  const ::pg_query::A_Indices& _internal_a_indices() const;
  ::pg_query::A_Indices* _internal_mutable_a_indices();
  public:
  void unsafe_arena_set_allocated_a_indices(
      ::pg_query::A_Indices* a_indices);
  ::pg_query::A_Indices* unsafe_arena_release_a_indices();

  // .pg_query.A_Indirection a_indirection = 174 [json_name = "A_Indirection"];
  bool has_a_indirection() const;
  private:
  bool _internal_has_a_indirection() const;
  public:
  void clear_a_indirection();
  const ::pg_query::A_Indirection& a_indirection() const;
  ::pg_query::A_Indirection* release_a_indirection();
  ::pg_query::A_Indirection* mutable_a_indirection();
  void set_allocated_a_indirection(::pg_query::A_Indirection* a_indirection);
  private:
  const ::pg_query::A_Indirection& _internal_a_indirection() const;
  ::pg_query::A_Indirection* _internal_mutable_a_indirection();
  public:
  void unsafe_arena_set_allocated_a_indirection(
      ::pg_query::A_Indirection* a_indirection);
  ::pg_query::A_Indirection* unsafe_arena_release_a_indirection();

  // .pg_query.A_ArrayExpr a_array_expr = 175 [json_name = "A_ArrayExpr"];
  bool has_a_array_expr() const;
  private:
  bool _internal_has_a_array_expr() const;
  public:
  void clear_a_array_expr();
  const ::pg_query::A_ArrayExpr& a_array_expr() const;
  ::pg_query::A_ArrayExpr* release_a_array_expr();
  ::pg_query::A_ArrayExpr* mutable_a_array_expr();
  void set_allocated_a_array_expr(::pg_query::A_ArrayExpr* a_array_expr);
  private:
  const ::pg_query::A_ArrayExpr& _internal_a_array_expr() const;
  ::pg_query::A_ArrayExpr* _internal_mutable_a_array_expr();
  public:
  void unsafe_arena_set_allocated_a_array_expr(
      ::pg_query::A_ArrayExpr* a_array_expr);
  ::pg_query::A_ArrayExpr* unsafe_arena_release_a_array_expr();

  // .pg_query.ResTarget res_target = 176 [json_name = "ResTarget"];
  bool has_res_target() const;
  private:
  bool _internal_has_res_target() const;
  public:
  void clear_res_target();
  const ::pg_query::ResTarget& res_target() const;
  ::pg_query::ResTarget* release_res_target();
  ::pg_query::ResTarget* mutable_res_target();
  void set_allocated_res_target(::pg_query::ResTarget* res_target);
  private:
  const ::pg_query::ResTarget& _internal_res_target() const;
  ::pg_query::ResTarget* _internal_mutable_res_target();
  public:
  void unsafe_arena_set_allocated_res_target(
      ::pg_query::ResTarget* res_target);
  ::pg_query::ResTarget* unsafe_arena_release_res_target();

  // .pg_query.MultiAssignRef multi_assign_ref = 177 [json_name = "MultiAssignRef"];
  bool has_multi_assign_ref() const;
  private:
  bool _internal_has_multi_assign_ref() const;
  public:
  void clear_multi_assign_ref();
  const ::pg_query::MultiAssignRef& multi_assign_ref() const;
  ::pg_query::MultiAssignRef* release_multi_assign_ref();
  ::pg_query::MultiAssignRef* mutable_multi_assign_ref();
  void set_allocated_multi_assign_ref(::pg_query::MultiAssignRef* multi_assign_ref);
  private:
  const ::pg_query::MultiAssignRef& _internal_multi_assign_ref() const;
  ::pg_query::MultiAssignRef* _internal_mutable_multi_assign_ref();
  public:
  void unsafe_arena_set_allocated_multi_assign_ref(
      ::pg_query::MultiAssignRef* multi_assign_ref);
  ::pg_query::MultiAssignRef* unsafe_arena_release_multi_assign_ref();

  // .pg_query.TypeCast type_cast = 178 [json_name = "TypeCast"];
  bool has_type_cast() const;
  private:
  bool _internal_has_type_cast() const;
  public:
  void clear_type_cast();
  const ::pg_query::TypeCast& type_cast() const;
  ::pg_query::TypeCast* release_type_cast();
  ::pg_query::TypeCast* mutable_type_cast();
  void set_allocated_type_cast(::pg_query::TypeCast* type_cast);
  private:
  const ::pg_query::TypeCast& _internal_type_cast() const;
  ::pg_query::TypeCast* _internal_mutable_type_cast();
  public:
  void unsafe_arena_set_allocated_type_cast(
      ::pg_query::TypeCast* type_cast);
  ::pg_query::TypeCast* unsafe_arena_release_type_cast();

  // .pg_query.CollateClause collate_clause = 179 [json_name = "CollateClause"];
  bool has_collate_clause() const;
  private:
  bool _internal_has_collate_clause() const;
  public:
  void clear_collate_clause();
  const ::pg_query::CollateClause& collate_clause() const;
  ::pg_query::CollateClause* release_collate_clause();
  ::pg_query::CollateClause* mutable_collate_clause();
  void set_allocated_collate_clause(::pg_query::CollateClause* collate_clause);
  private:
  const ::pg_query::CollateClause& _internal_collate_clause() const;
  ::pg_query::CollateClause* _internal_mutable_collate_clause();
  public:
  void unsafe_arena_set_allocated_collate_clause(
      ::pg_query::CollateClause* collate_clause);
  ::pg_query::CollateClause* unsafe_arena_release_collate_clause();

  // .pg_query.SortBy sort_by = 180 [json_name = "SortBy"];
  bool has_sort_by() const;
  private:
  bool _internal_has_sort_by() const;
  public:
  void clear_sort_by();
  const ::pg_query::SortBy& sort_by() const;
  ::pg_query::SortBy* release_sort_by();
  ::pg_query::SortBy* mutable_sort_by();
  void set_allocated_sort_by(::pg_query::SortBy* sort_by);
  private:
  const ::pg_query::SortBy& _internal_sort_by() const;
  ::pg_query::SortBy* _internal_mutable_sort_by();
  public:
  void unsafe_arena_set_allocated_sort_by(
      ::pg_query::SortBy* sort_by);
  ::pg_query::SortBy* unsafe_arena_release_sort_by();

  // .pg_query.WindowDef window_def = 181 [json_name = "WindowDef"];
  bool has_window_def() const;
  private:
  bool _internal_has_window_def() const;
  public:
  void clear_window_def();
  const ::pg_query::WindowDef& window_def() const;
  ::pg_query::WindowDef* release_window_def();
  ::pg_query::WindowDef* mutable_window_def();
  void set_allocated_window_def(::pg_query::WindowDef* window_def);
  private:
  const ::pg_query::WindowDef& _internal_window_def() const;
  ::pg_query::WindowDef* _internal_mutable_window_def();
  public:
  void unsafe_arena_set_allocated_window_def(
      ::pg_query::WindowDef* window_def);
  ::pg_query::WindowDef* unsafe_arena_release_window_def();

  // .pg_query.RangeSubselect range_subselect = 182 [json_name = "RangeSubselect"];
  bool has_range_subselect() const;
  private:
  bool _internal_has_range_subselect() const;
  public:
  void clear_range_subselect();
  const ::pg_query::RangeSubselect& range_subselect() const;
  ::pg_query::RangeSubselect* release_range_subselect();
  ::pg_query::RangeSubselect* mutable_range_subselect();
  void set_allocated_range_subselect(::pg_query::RangeSubselect* range_subselect);
  private:
  const ::pg_query::RangeSubselect& _internal_range_subselect() const;
  ::pg_query::RangeSubselect* _internal_mutable_range_subselect();
  public:
  void unsafe_arena_set_allocated_range_subselect(
      ::pg_query::RangeSubselect* range_subselect);
  ::pg_query::RangeSubselect* unsafe_arena_release_range_subselect();

  // .pg_query.RangeFunction range_function = 183 [json_name = "RangeFunction"];
  bool has_range_function() const;
  private:
  bool _internal_has_range_function() const;
  public:
  void clear_range_function();
  const ::pg_query::RangeFunction& range_function() const;
  ::pg_query::RangeFunction* release_range_function();
  ::pg_query::RangeFunction* mutable_range_function();
  void set_allocated_range_function(::pg_query::RangeFunction* range_function);
  private:
  const ::pg_query::RangeFunction& _internal_range_function() const;
  ::pg_query::RangeFunction* _internal_mutable_range_function();
  public:
  void unsafe_arena_set_allocated_range_function(
      ::pg_query::RangeFunction* range_function);
  ::pg_query::RangeFunction* unsafe_arena_release_range_function();

  // .pg_query.RangeTableSample range_table_sample = 184 [json_name = "RangeTableSample"];
  bool has_range_table_sample() const;
  private:
  bool _internal_has_range_table_sample() const;
  public:
  void clear_range_table_sample();
  const ::pg_query::RangeTableSample& range_table_sample() const;
  ::pg_query::RangeTableSample* release_range_table_sample();
  ::pg_query::RangeTableSample* mutable_range_table_sample();
  void set_allocated_range_table_sample(::pg_query::RangeTableSample* range_table_sample);
  private:
  const ::pg_query::RangeTableSample& _internal_range_table_sample() const;
  ::pg_query::RangeTableSample* _internal_mutable_range_table_sample();
  public:
  void unsafe_arena_set_allocated_range_table_sample(
      ::pg_query::RangeTableSample* range_table_sample);
  ::pg_query::RangeTableSample* unsafe_arena_release_range_table_sample();

  // .pg_query.RangeTableFunc range_table_func = 185 [json_name = "RangeTableFunc"];
  bool has_range_table_func() const;
  private:
  bool _internal_has_range_table_func() const;
  public:
  void clear_range_table_func();
  const ::pg_query::RangeTableFunc& range_table_func() const;
  ::pg_query::RangeTableFunc* release_range_table_func();
  ::pg_query::RangeTableFunc* mutable_range_table_func();
  void set_allocated_range_table_func(::pg_query::RangeTableFunc* range_table_func);
  private:
  const ::pg_query::RangeTableFunc& _internal_range_table_func() const;
  ::pg_query::RangeTableFunc* _internal_mutable_range_table_func();
  public:
  void unsafe_arena_set_allocated_range_table_func(
      ::pg_query::RangeTableFunc* range_table_func);
  ::pg_query::RangeTableFunc* unsafe_arena_release_range_table_func();

  // .pg_query.RangeTableFuncCol range_table_func_col = 186 [json_name = "RangeTableFuncCol"];
  bool has_range_table_func_col() const;
  private:
  bool _internal_has_range_table_func_col() const;
  public:
  void clear_range_table_func_col();
  const ::pg_query::RangeTableFuncCol& range_table_func_col() const;
  ::pg_query::RangeTableFuncCol* release_range_table_func_col();
  ::pg_query::RangeTableFuncCol* mutable_range_table_func_col();
  void set_allocated_range_table_func_col(::pg_query::RangeTableFuncCol* range_table_func_col);
  private:
  const ::pg_query::RangeTableFuncCol& _internal_range_table_func_col() const;
  ::pg_query::RangeTableFuncCol* _internal_mutable_range_table_func_col();
  public:
  void unsafe_arena_set_allocated_range_table_func_col(
      ::pg_query::RangeTableFuncCol* range_table_func_col);
  ::pg_query::RangeTableFuncCol* unsafe_arena_release_range_table_func_col();

  // .pg_query.TypeName type_name = 187 [json_name = "TypeName"];
  bool has_type_name() const;
  private:
  bool _internal_has_type_name() const;
  public:
  void clear_type_name();
  const ::pg_query::TypeName& type_name() const;
  ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* type_name);
  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();
  public:
  void unsafe_arena_set_allocated_type_name(
      ::pg_query::TypeName* type_name);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  // .pg_query.ColumnDef column_def = 188 [json_name = "ColumnDef"];
  bool has_column_def() const;
  private:
  bool _internal_has_column_def() const;
  public:
  void clear_column_def();
  const ::pg_query::ColumnDef& column_def() const;
  ::pg_query::ColumnDef* release_column_def();
  ::pg_query::ColumnDef* mutable_column_def();
  void set_allocated_column_def(::pg_query::ColumnDef* column_def);
  private:
  const ::pg_query::ColumnDef& _internal_column_def() const;
  ::pg_query::ColumnDef* _internal_mutable_column_def();
  public:
  void unsafe_arena_set_allocated_column_def(
      ::pg_query::ColumnDef* column_def);
  ::pg_query::ColumnDef* unsafe_arena_release_column_def();

  // .pg_query.IndexElem index_elem = 189 [json_name = "IndexElem"];
  bool has_index_elem() const;
  private:
  bool _internal_has_index_elem() const;
  public:
  void clear_index_elem();
  const ::pg_query::IndexElem& index_elem() const;
  ::pg_query::IndexElem* release_index_elem();
  ::pg_query::IndexElem* mutable_index_elem();
  void set_allocated_index_elem(::pg_query::IndexElem* index_elem);
  private:
  const ::pg_query::IndexElem& _internal_index_elem() const;
  ::pg_query::IndexElem* _internal_mutable_index_elem();
  public:
  void unsafe_arena_set_allocated_index_elem(
      ::pg_query::IndexElem* index_elem);
  ::pg_query::IndexElem* unsafe_arena_release_index_elem();

  // .pg_query.Constraint constraint = 190 [json_name = "Constraint"];
  bool has_constraint() const;
  private:
  bool _internal_has_constraint() const;
  public:
  void clear_constraint();
  const ::pg_query::Constraint& constraint() const;
  ::pg_query::Constraint* release_constraint();
  ::pg_query::Constraint* mutable_constraint();
  void set_allocated_constraint(::pg_query::Constraint* constraint);
  private:
  const ::pg_query::Constraint& _internal_constraint() const;
  ::pg_query::Constraint* _internal_mutable_constraint();
  public:
  void unsafe_arena_set_allocated_constraint(
      ::pg_query::Constraint* constraint);
  ::pg_query::Constraint* unsafe_arena_release_constraint();

  // .pg_query.DefElem def_elem = 191 [json_name = "DefElem"];
  bool has_def_elem() const;
  private:
  bool _internal_has_def_elem() const;
  public:
  void clear_def_elem();
  const ::pg_query::DefElem& def_elem() const;
  ::pg_query::DefElem* release_def_elem();
  ::pg_query::DefElem* mutable_def_elem();
  void set_allocated_def_elem(::pg_query::DefElem* def_elem);
  private:
  const ::pg_query::DefElem& _internal_def_elem() const;
  ::pg_query::DefElem* _internal_mutable_def_elem();
  public:
  void unsafe_arena_set_allocated_def_elem(
      ::pg_query::DefElem* def_elem);
  ::pg_query::DefElem* unsafe_arena_release_def_elem();

  // .pg_query.RangeTblEntry range_tbl_entry = 192 [json_name = "RangeTblEntry"];
  bool has_range_tbl_entry() const;
  private:
  bool _internal_has_range_tbl_entry() const;
  public:
  void clear_range_tbl_entry();
  const ::pg_query::RangeTblEntry& range_tbl_entry() const;
  ::pg_query::RangeTblEntry* release_range_tbl_entry();
  ::pg_query::RangeTblEntry* mutable_range_tbl_entry();
  void set_allocated_range_tbl_entry(::pg_query::RangeTblEntry* range_tbl_entry);
  private:
  const ::pg_query::RangeTblEntry& _internal_range_tbl_entry() const;
  ::pg_query::RangeTblEntry* _internal_mutable_range_tbl_entry();
  public:
  void unsafe_arena_set_allocated_range_tbl_entry(
      ::pg_query::RangeTblEntry* range_tbl_entry);
  ::pg_query::RangeTblEntry* unsafe_arena_release_range_tbl_entry();

  // .pg_query.RangeTblFunction range_tbl_function = 193 [json_name = "RangeTblFunction"];
  bool has_range_tbl_function() const;
  private:
  bool _internal_has_range_tbl_function() const;
  public:
  void clear_range_tbl_function();
  const ::pg_query::RangeTblFunction& range_tbl_function() const;
  ::pg_query::RangeTblFunction* release_range_tbl_function();
  ::pg_query::RangeTblFunction* mutable_range_tbl_function();
  void set_allocated_range_tbl_function(::pg_query::RangeTblFunction* range_tbl_function);
  private:
  const ::pg_query::RangeTblFunction& _internal_range_tbl_function() const;
  ::pg_query::RangeTblFunction* _internal_mutable_range_tbl_function();
  public:
  void unsafe_arena_set_allocated_range_tbl_function(
      ::pg_query::RangeTblFunction* range_tbl_function);
  ::pg_query::RangeTblFunction* unsafe_arena_release_range_tbl_function();

  // .pg_query.TableSampleClause table_sample_clause = 194 [json_name = "TableSampleClause"];
  bool has_table_sample_clause() const;
  private:
  bool _internal_has_table_sample_clause() const;
  public:
  void clear_table_sample_clause();
  const ::pg_query::TableSampleClause& table_sample_clause() const;
  ::pg_query::TableSampleClause* release_table_sample_clause();
  ::pg_query::TableSampleClause* mutable_table_sample_clause();
  void set_allocated_table_sample_clause(::pg_query::TableSampleClause* table_sample_clause);
  private:
  const ::pg_query::TableSampleClause& _internal_table_sample_clause() const;
  ::pg_query::TableSampleClause* _internal_mutable_table_sample_clause();
  public:
  void unsafe_arena_set_allocated_table_sample_clause(
      ::pg_query::TableSampleClause* table_sample_clause);
  ::pg_query::TableSampleClause* unsafe_arena_release_table_sample_clause();

  // .pg_query.WithCheckOption with_check_option = 195 [json_name = "WithCheckOption"];
  bool has_with_check_option() const;
  private:
  bool _internal_has_with_check_option() const;
  public:
  void clear_with_check_option();
  const ::pg_query::WithCheckOption& with_check_option() const;
  ::pg_query::WithCheckOption* release_with_check_option();
  ::pg_query::WithCheckOption* mutable_with_check_option();
  void set_allocated_with_check_option(::pg_query::WithCheckOption* with_check_option);
  private:
  const ::pg_query::WithCheckOption& _internal_with_check_option() const;
  ::pg_query::WithCheckOption* _internal_mutable_with_check_option();
  public:
  void unsafe_arena_set_allocated_with_check_option(
      ::pg_query::WithCheckOption* with_check_option);
  ::pg_query::WithCheckOption* unsafe_arena_release_with_check_option();

  // .pg_query.SortGroupClause sort_group_clause = 196 [json_name = "SortGroupClause"];
  bool has_sort_group_clause() const;
  private:
  bool _internal_has_sort_group_clause() const;
  public:
  void clear_sort_group_clause();
  const ::pg_query::SortGroupClause& sort_group_clause() const;
  ::pg_query::SortGroupClause* release_sort_group_clause();
  ::pg_query::SortGroupClause* mutable_sort_group_clause();
  void set_allocated_sort_group_clause(::pg_query::SortGroupClause* sort_group_clause);
  private:
  const ::pg_query::SortGroupClause& _internal_sort_group_clause() const;
  ::pg_query::SortGroupClause* _internal_mutable_sort_group_clause();
  public:
  void unsafe_arena_set_allocated_sort_group_clause(
      ::pg_query::SortGroupClause* sort_group_clause);
  ::pg_query::SortGroupClause* unsafe_arena_release_sort_group_clause();

  // .pg_query.GroupingSet grouping_set = 197 [json_name = "GroupingSet"];
  bool has_grouping_set() const;
  private:
  bool _internal_has_grouping_set() const;
  public:
  void clear_grouping_set();
  const ::pg_query::GroupingSet& grouping_set() const;
  ::pg_query::GroupingSet* release_grouping_set();
  ::pg_query::GroupingSet* mutable_grouping_set();
  void set_allocated_grouping_set(::pg_query::GroupingSet* grouping_set);
  private:
  const ::pg_query::GroupingSet& _internal_grouping_set() const;
  ::pg_query::GroupingSet* _internal_mutable_grouping_set();
  public:
  void unsafe_arena_set_allocated_grouping_set(
      ::pg_query::GroupingSet* grouping_set);
  ::pg_query::GroupingSet* unsafe_arena_release_grouping_set();

  // .pg_query.WindowClause window_clause = 198 [json_name = "WindowClause"];
  bool has_window_clause() const;
  private:
  bool _internal_has_window_clause() const;
  public:
  void clear_window_clause();
  const ::pg_query::WindowClause& window_clause() const;
  ::pg_query::WindowClause* release_window_clause();
  ::pg_query::WindowClause* mutable_window_clause();
  void set_allocated_window_clause(::pg_query::WindowClause* window_clause);
  private:
  const ::pg_query::WindowClause& _internal_window_clause() const;
  ::pg_query::WindowClause* _internal_mutable_window_clause();
  public:
  void unsafe_arena_set_allocated_window_clause(
      ::pg_query::WindowClause* window_clause);
  ::pg_query::WindowClause* unsafe_arena_release_window_clause();

  // .pg_query.ObjectWithArgs object_with_args = 199 [json_name = "ObjectWithArgs"];
  bool has_object_with_args() const;
  private:
  bool _internal_has_object_with_args() const;
  public:
  void clear_object_with_args();
  const ::pg_query::ObjectWithArgs& object_with_args() const;
  ::pg_query::ObjectWithArgs* release_object_with_args();
  ::pg_query::ObjectWithArgs* mutable_object_with_args();
  void set_allocated_object_with_args(::pg_query::ObjectWithArgs* object_with_args);
  private:
  const ::pg_query::ObjectWithArgs& _internal_object_with_args() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_object_with_args();
  public:
  void unsafe_arena_set_allocated_object_with_args(
      ::pg_query::ObjectWithArgs* object_with_args);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_object_with_args();

  // .pg_query.AccessPriv access_priv = 200 [json_name = "AccessPriv"];
  bool has_access_priv() const;
  private:
  bool _internal_has_access_priv() const;
  public:
  void clear_access_priv();
  const ::pg_query::AccessPriv& access_priv() const;
  ::pg_query::AccessPriv* release_access_priv();
  ::pg_query::AccessPriv* mutable_access_priv();
  void set_allocated_access_priv(::pg_query::AccessPriv* access_priv);
  private:
  const ::pg_query::AccessPriv& _internal_access_priv() const;
  ::pg_query::AccessPriv* _internal_mutable_access_priv();
  public:
  void unsafe_arena_set_allocated_access_priv(
      ::pg_query::AccessPriv* access_priv);
  ::pg_query::AccessPriv* unsafe_arena_release_access_priv();

  // .pg_query.CreateOpClassItem create_op_class_item = 201 [json_name = "CreateOpClassItem"];
  bool has_create_op_class_item() const;
  private:
  bool _internal_has_create_op_class_item() const;
  public:
  void clear_create_op_class_item();
  const ::pg_query::CreateOpClassItem& create_op_class_item() const;
  ::pg_query::CreateOpClassItem* release_create_op_class_item();
  ::pg_query::CreateOpClassItem* mutable_create_op_class_item();
  void set_allocated_create_op_class_item(::pg_query::CreateOpClassItem* create_op_class_item);
  private:
  const ::pg_query::CreateOpClassItem& _internal_create_op_class_item() const;
  ::pg_query::CreateOpClassItem* _internal_mutable_create_op_class_item();
  public:
  void unsafe_arena_set_allocated_create_op_class_item(
      ::pg_query::CreateOpClassItem* create_op_class_item);
  ::pg_query::CreateOpClassItem* unsafe_arena_release_create_op_class_item();

  // .pg_query.TableLikeClause table_like_clause = 202 [json_name = "TableLikeClause"];
  bool has_table_like_clause() const;
  private:
  bool _internal_has_table_like_clause() const;
  public:
  void clear_table_like_clause();
  const ::pg_query::TableLikeClause& table_like_clause() const;
  ::pg_query::TableLikeClause* release_table_like_clause();
  ::pg_query::TableLikeClause* mutable_table_like_clause();
  void set_allocated_table_like_clause(::pg_query::TableLikeClause* table_like_clause);
  private:
  const ::pg_query::TableLikeClause& _internal_table_like_clause() const;
  ::pg_query::TableLikeClause* _internal_mutable_table_like_clause();
  public:
  void unsafe_arena_set_allocated_table_like_clause(
      ::pg_query::TableLikeClause* table_like_clause);
  ::pg_query::TableLikeClause* unsafe_arena_release_table_like_clause();

  // .pg_query.FunctionParameter function_parameter = 203 [json_name = "FunctionParameter"];
  bool has_function_parameter() const;
  private:
  bool _internal_has_function_parameter() const;
  public:
  void clear_function_parameter();
  const ::pg_query::FunctionParameter& function_parameter() const;
  ::pg_query::FunctionParameter* release_function_parameter();
  ::pg_query::FunctionParameter* mutable_function_parameter();
  void set_allocated_function_parameter(::pg_query::FunctionParameter* function_parameter);
  private:
  const ::pg_query::FunctionParameter& _internal_function_parameter() const;
  ::pg_query::FunctionParameter* _internal_mutable_function_parameter();
  public:
  void unsafe_arena_set_allocated_function_parameter(
      ::pg_query::FunctionParameter* function_parameter);
  ::pg_query::FunctionParameter* unsafe_arena_release_function_parameter();

  // .pg_query.LockingClause locking_clause = 204 [json_name = "LockingClause"];
  bool has_locking_clause() const;
  private:
  bool _internal_has_locking_clause() const;
  public:
  void clear_locking_clause();
  const ::pg_query::LockingClause& locking_clause() const;
  ::pg_query::LockingClause* release_locking_clause();
  ::pg_query::LockingClause* mutable_locking_clause();
  void set_allocated_locking_clause(::pg_query::LockingClause* locking_clause);
  private:
  const ::pg_query::LockingClause& _internal_locking_clause() const;
  ::pg_query::LockingClause* _internal_mutable_locking_clause();
  public:
  void unsafe_arena_set_allocated_locking_clause(
      ::pg_query::LockingClause* locking_clause);
  ::pg_query::LockingClause* unsafe_arena_release_locking_clause();

  // .pg_query.RowMarkClause row_mark_clause = 205 [json_name = "RowMarkClause"];
  bool has_row_mark_clause() const;
  private:
  bool _internal_has_row_mark_clause() const;
  public:
  void clear_row_mark_clause();
  const ::pg_query::RowMarkClause& row_mark_clause() const;
  ::pg_query::RowMarkClause* release_row_mark_clause();
  ::pg_query::RowMarkClause* mutable_row_mark_clause();
  void set_allocated_row_mark_clause(::pg_query::RowMarkClause* row_mark_clause);
  private:
  const ::pg_query::RowMarkClause& _internal_row_mark_clause() const;
  ::pg_query::RowMarkClause* _internal_mutable_row_mark_clause();
  public:
  void unsafe_arena_set_allocated_row_mark_clause(
      ::pg_query::RowMarkClause* row_mark_clause);
  ::pg_query::RowMarkClause* unsafe_arena_release_row_mark_clause();

  // .pg_query.XmlSerialize xml_serialize = 206 [json_name = "XmlSerialize"];
  bool has_xml_serialize() const;
  private:
  bool _internal_has_xml_serialize() const;
  public:
  void clear_xml_serialize();
  const ::pg_query::XmlSerialize& xml_serialize() const;
  ::pg_query::XmlSerialize* release_xml_serialize();
  ::pg_query::XmlSerialize* mutable_xml_serialize();
  void set_allocated_xml_serialize(::pg_query::XmlSerialize* xml_serialize);
  private:
  const ::pg_query::XmlSerialize& _internal_xml_serialize() const;
  ::pg_query::XmlSerialize* _internal_mutable_xml_serialize();
  public:
  void unsafe_arena_set_allocated_xml_serialize(
      ::pg_query::XmlSerialize* xml_serialize);
  ::pg_query::XmlSerialize* unsafe_arena_release_xml_serialize();

  // .pg_query.WithClause with_clause = 207 [json_name = "WithClause"];
  bool has_with_clause() const;
  private:
  bool _internal_has_with_clause() const;
  public:
  void clear_with_clause();
  const ::pg_query::WithClause& with_clause() const;
  ::pg_query::WithClause* release_with_clause();
  ::pg_query::WithClause* mutable_with_clause();
  void set_allocated_with_clause(::pg_query::WithClause* with_clause);
  private:
  const ::pg_query::WithClause& _internal_with_clause() const;
  ::pg_query::WithClause* _internal_mutable_with_clause();
  public:
  void unsafe_arena_set_allocated_with_clause(
      ::pg_query::WithClause* with_clause);
  ::pg_query::WithClause* unsafe_arena_release_with_clause();

  // .pg_query.InferClause infer_clause = 208 [json_name = "InferClause"];
  bool has_infer_clause() const;
  private:
  bool _internal_has_infer_clause() const;
  public:
  void clear_infer_clause();
  const ::pg_query::InferClause& infer_clause() const;
  ::pg_query::InferClause* release_infer_clause();
  ::pg_query::InferClause* mutable_infer_clause();
  void set_allocated_infer_clause(::pg_query::InferClause* infer_clause);
  private:
  const ::pg_query::InferClause& _internal_infer_clause() const;
  ::pg_query::InferClause* _internal_mutable_infer_clause();
  public:
  void unsafe_arena_set_allocated_infer_clause(
      ::pg_query::InferClause* infer_clause);
  ::pg_query::InferClause* unsafe_arena_release_infer_clause();

  // .pg_query.OnConflictClause on_conflict_clause = 209 [json_name = "OnConflictClause"];
  bool has_on_conflict_clause() const;
  private:
  bool _internal_has_on_conflict_clause() const;
  public:
  void clear_on_conflict_clause();
  const ::pg_query::OnConflictClause& on_conflict_clause() const;
  ::pg_query::OnConflictClause* release_on_conflict_clause();
  ::pg_query::OnConflictClause* mutable_on_conflict_clause();
  void set_allocated_on_conflict_clause(::pg_query::OnConflictClause* on_conflict_clause);
  private:
  const ::pg_query::OnConflictClause& _internal_on_conflict_clause() const;
  ::pg_query::OnConflictClause* _internal_mutable_on_conflict_clause();
  public:
  void unsafe_arena_set_allocated_on_conflict_clause(
      ::pg_query::OnConflictClause* on_conflict_clause);
  ::pg_query::OnConflictClause* unsafe_arena_release_on_conflict_clause();

  // .pg_query.CommonTableExpr common_table_expr = 210 [json_name = "CommonTableExpr"];
  bool has_common_table_expr() const;
  private:
  bool _internal_has_common_table_expr() const;
  public:
  void clear_common_table_expr();
  const ::pg_query::CommonTableExpr& common_table_expr() const;
  ::pg_query::CommonTableExpr* release_common_table_expr();
  ::pg_query::CommonTableExpr* mutable_common_table_expr();
  void set_allocated_common_table_expr(::pg_query::CommonTableExpr* common_table_expr);
  private:
  const ::pg_query::CommonTableExpr& _internal_common_table_expr() const;
  ::pg_query::CommonTableExpr* _internal_mutable_common_table_expr();
  public:
  void unsafe_arena_set_allocated_common_table_expr(
      ::pg_query::CommonTableExpr* common_table_expr);
  ::pg_query::CommonTableExpr* unsafe_arena_release_common_table_expr();

  // .pg_query.RoleSpec role_spec = 211 [json_name = "RoleSpec"];
  bool has_role_spec() const;
  private:
  bool _internal_has_role_spec() const;
  public:
  void clear_role_spec();
  const ::pg_query::RoleSpec& role_spec() const;
  ::pg_query::RoleSpec* release_role_spec();
  ::pg_query::RoleSpec* mutable_role_spec();
  void set_allocated_role_spec(::pg_query::RoleSpec* role_spec);
  private:
  const ::pg_query::RoleSpec& _internal_role_spec() const;
  ::pg_query::RoleSpec* _internal_mutable_role_spec();
  public:
  void unsafe_arena_set_allocated_role_spec(
      ::pg_query::RoleSpec* role_spec);
  ::pg_query::RoleSpec* unsafe_arena_release_role_spec();

  // .pg_query.TriggerTransition trigger_transition = 212 [json_name = "TriggerTransition"];
  bool has_trigger_transition() const;
  private:
  bool _internal_has_trigger_transition() const;
  public:
  void clear_trigger_transition();
  const ::pg_query::TriggerTransition& trigger_transition() const;
  ::pg_query::TriggerTransition* release_trigger_transition();
  ::pg_query::TriggerTransition* mutable_trigger_transition();
  void set_allocated_trigger_transition(::pg_query::TriggerTransition* trigger_transition);
  private:
  const ::pg_query::TriggerTransition& _internal_trigger_transition() const;
  ::pg_query::TriggerTransition* _internal_mutable_trigger_transition();
  public:
  void unsafe_arena_set_allocated_trigger_transition(
      ::pg_query::TriggerTransition* trigger_transition);
  ::pg_query::TriggerTransition* unsafe_arena_release_trigger_transition();

  // .pg_query.PartitionElem partition_elem = 213 [json_name = "PartitionElem"];
  bool has_partition_elem() const;
  private:
  bool _internal_has_partition_elem() const;
  public:
  void clear_partition_elem();
  const ::pg_query::PartitionElem& partition_elem() const;
  ::pg_query::PartitionElem* release_partition_elem();
  ::pg_query::PartitionElem* mutable_partition_elem();
  void set_allocated_partition_elem(::pg_query::PartitionElem* partition_elem);
  private:
  const ::pg_query::PartitionElem& _internal_partition_elem() const;
  ::pg_query::PartitionElem* _internal_mutable_partition_elem();
  public:
  void unsafe_arena_set_allocated_partition_elem(
      ::pg_query::PartitionElem* partition_elem);
  ::pg_query::PartitionElem* unsafe_arena_release_partition_elem();

  // .pg_query.PartitionSpec partition_spec = 214 [json_name = "PartitionSpec"];
  bool has_partition_spec() const;
  private:
  bool _internal_has_partition_spec() const;
  public:
  void clear_partition_spec();
  const ::pg_query::PartitionSpec& partition_spec() const;
  ::pg_query::PartitionSpec* release_partition_spec();
  ::pg_query::PartitionSpec* mutable_partition_spec();
  void set_allocated_partition_spec(::pg_query::PartitionSpec* partition_spec);
  private:
  const ::pg_query::PartitionSpec& _internal_partition_spec() const;
  ::pg_query::PartitionSpec* _internal_mutable_partition_spec();
  public:
  void unsafe_arena_set_allocated_partition_spec(
      ::pg_query::PartitionSpec* partition_spec);
  ::pg_query::PartitionSpec* unsafe_arena_release_partition_spec();

  // .pg_query.PartitionBoundSpec partition_bound_spec = 215 [json_name = "PartitionBoundSpec"];
  bool has_partition_bound_spec() const;
  private:
  bool _internal_has_partition_bound_spec() const;
  public:
  void clear_partition_bound_spec();
  const ::pg_query::PartitionBoundSpec& partition_bound_spec() const;
  ::pg_query::PartitionBoundSpec* release_partition_bound_spec();
  ::pg_query::PartitionBoundSpec* mutable_partition_bound_spec();
  void set_allocated_partition_bound_spec(::pg_query::PartitionBoundSpec* partition_bound_spec);
  private:
  const ::pg_query::PartitionBoundSpec& _internal_partition_bound_spec() const;
  ::pg_query::PartitionBoundSpec* _internal_mutable_partition_bound_spec();
  public:
  void unsafe_arena_set_allocated_partition_bound_spec(
      ::pg_query::PartitionBoundSpec* partition_bound_spec);
  ::pg_query::PartitionBoundSpec* unsafe_arena_release_partition_bound_spec();

  // .pg_query.PartitionRangeDatum partition_range_datum = 216 [json_name = "PartitionRangeDatum"];
  bool has_partition_range_datum() const;
  private:
  bool _internal_has_partition_range_datum() const;
  public:
  void clear_partition_range_datum();
  const ::pg_query::PartitionRangeDatum& partition_range_datum() const;
  ::pg_query::PartitionRangeDatum* release_partition_range_datum();
  ::pg_query::PartitionRangeDatum* mutable_partition_range_datum();
  void set_allocated_partition_range_datum(::pg_query::PartitionRangeDatum* partition_range_datum);
  private:
  const ::pg_query::PartitionRangeDatum& _internal_partition_range_datum() const;
  ::pg_query::PartitionRangeDatum* _internal_mutable_partition_range_datum();
  public:
  void unsafe_arena_set_allocated_partition_range_datum(
      ::pg_query::PartitionRangeDatum* partition_range_datum);
  ::pg_query::PartitionRangeDatum* unsafe_arena_release_partition_range_datum();

  // .pg_query.PartitionCmd partition_cmd = 217 [json_name = "PartitionCmd"];
  bool has_partition_cmd() const;
  private:
  bool _internal_has_partition_cmd() const;
  public:
  void clear_partition_cmd();
  const ::pg_query::PartitionCmd& partition_cmd() const;
  ::pg_query::PartitionCmd* release_partition_cmd();
  ::pg_query::PartitionCmd* mutable_partition_cmd();
  void set_allocated_partition_cmd(::pg_query::PartitionCmd* partition_cmd);
  private:
  const ::pg_query::PartitionCmd& _internal_partition_cmd() const;
  ::pg_query::PartitionCmd* _internal_mutable_partition_cmd();
  public:
  void unsafe_arena_set_allocated_partition_cmd(
      ::pg_query::PartitionCmd* partition_cmd);
  ::pg_query::PartitionCmd* unsafe_arena_release_partition_cmd();

  // .pg_query.VacuumRelation vacuum_relation = 218 [json_name = "VacuumRelation"];
  bool has_vacuum_relation() const;
  private:
  bool _internal_has_vacuum_relation() const;
  public:
  void clear_vacuum_relation();
  const ::pg_query::VacuumRelation& vacuum_relation() const;
  ::pg_query::VacuumRelation* release_vacuum_relation();
  ::pg_query::VacuumRelation* mutable_vacuum_relation();
  void set_allocated_vacuum_relation(::pg_query::VacuumRelation* vacuum_relation);
  private:
  const ::pg_query::VacuumRelation& _internal_vacuum_relation() const;
  ::pg_query::VacuumRelation* _internal_mutable_vacuum_relation();
  public:
  void unsafe_arena_set_allocated_vacuum_relation(
      ::pg_query::VacuumRelation* vacuum_relation);
  ::pg_query::VacuumRelation* unsafe_arena_release_vacuum_relation();

  // .pg_query.InlineCodeBlock inline_code_block = 219 [json_name = "InlineCodeBlock"];
  bool has_inline_code_block() const;
  private:
  bool _internal_has_inline_code_block() const;
  public:
  void clear_inline_code_block();
  const ::pg_query::InlineCodeBlock& inline_code_block() const;
  ::pg_query::InlineCodeBlock* release_inline_code_block();
  ::pg_query::InlineCodeBlock* mutable_inline_code_block();
  void set_allocated_inline_code_block(::pg_query::InlineCodeBlock* inline_code_block);
  private:
  const ::pg_query::InlineCodeBlock& _internal_inline_code_block() const;
  ::pg_query::InlineCodeBlock* _internal_mutable_inline_code_block();
  public:
  void unsafe_arena_set_allocated_inline_code_block(
      ::pg_query::InlineCodeBlock* inline_code_block);
  ::pg_query::InlineCodeBlock* unsafe_arena_release_inline_code_block();

  // .pg_query.CallContext call_context = 220 [json_name = "CallContext"];
  bool has_call_context() const;
  private:
  bool _internal_has_call_context() const;
  public:
  void clear_call_context();
  const ::pg_query::CallContext& call_context() const;
  ::pg_query::CallContext* release_call_context();
  ::pg_query::CallContext* mutable_call_context();
  void set_allocated_call_context(::pg_query::CallContext* call_context);
  private:
  const ::pg_query::CallContext& _internal_call_context() const;
  ::pg_query::CallContext* _internal_mutable_call_context();
  public:
  void unsafe_arena_set_allocated_call_context(
      ::pg_query::CallContext* call_context);
  ::pg_query::CallContext* unsafe_arena_release_call_context();

  // .pg_query.Integer integer = 221 [json_name = "Integer"];
  bool has_integer() const;
  private:
  bool _internal_has_integer() const;
  public:
  void clear_integer();
  const ::pg_query::Integer& integer() const;
  ::pg_query::Integer* release_integer();
  ::pg_query::Integer* mutable_integer();
  void set_allocated_integer(::pg_query::Integer* integer);
  private:
  const ::pg_query::Integer& _internal_integer() const;
  ::pg_query::Integer* _internal_mutable_integer();
  public:
  void unsafe_arena_set_allocated_integer(
      ::pg_query::Integer* integer);
  ::pg_query::Integer* unsafe_arena_release_integer();

  // .pg_query.Float float = 222 [json_name = "Float"];
  bool has_float_() const;
  private:
  bool _internal_has_float_() const;
  public:
  void clear_float_();
  const ::pg_query::Float& float_() const;
  ::pg_query::Float* release_float_();
  ::pg_query::Float* mutable_float_();
  void set_allocated_float_(::pg_query::Float* float_);
  private:
  const ::pg_query::Float& _internal_float_() const;
  ::pg_query::Float* _internal_mutable_float_();
  public:
  void unsafe_arena_set_allocated_float_(
      ::pg_query::Float* float_);
  ::pg_query::Float* unsafe_arena_release_float_();

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

  // .pg_query.BitString bit_string = 224 [json_name = "BitString"];
  bool has_bit_string() const;
  private:
  bool _internal_has_bit_string() const;
  public:
  void clear_bit_string();
  const ::pg_query::BitString& bit_string() const;
  ::pg_query::BitString* release_bit_string();
  ::pg_query::BitString* mutable_bit_string();
  void set_allocated_bit_string(::pg_query::BitString* bit_string);
  private:
  const ::pg_query::BitString& _internal_bit_string() const;
  ::pg_query::BitString* _internal_mutable_bit_string();
  public:
  void unsafe_arena_set_allocated_bit_string(
      ::pg_query::BitString* bit_string);
  ::pg_query::BitString* unsafe_arena_release_bit_string();

  // .pg_query.Null null = 225 [json_name = "Null"];
  bool has_null() const;
  private:
  bool _internal_has_null() const;
  public:
  void clear_null();
  const ::pg_query::Null& null() const;
  ::pg_query::Null* release_null();
  ::pg_query::Null* mutable_null();
  void set_allocated_null(::pg_query::Null* null);
  private:
  const ::pg_query::Null& _internal_null() const;
  ::pg_query::Null* _internal_mutable_null();
  public:
  void unsafe_arena_set_allocated_null(
      ::pg_query::Null* null);
  ::pg_query::Null* unsafe_arena_release_null();

  // .pg_query.List list = 226 [json_name = "List"];
  bool has_list() const;
  private:
  bool _internal_has_list() const;
  public:
  void clear_list();
  const ::pg_query::List& list() const;
  ::pg_query::List* release_list();
  ::pg_query::List* mutable_list();
  void set_allocated_list(::pg_query::List* list);
  private:
  const ::pg_query::List& _internal_list() const;
  ::pg_query::List* _internal_mutable_list();
  public:
  void unsafe_arena_set_allocated_list(
      ::pg_query::List* list);
  ::pg_query::List* unsafe_arena_release_list();

  // .pg_query.IntList int_list = 227 [json_name = "IntList"];
  bool has_int_list() const;
  private:
  bool _internal_has_int_list() const;
  public:
  void clear_int_list();
  const ::pg_query::IntList& int_list() const;
  ::pg_query::IntList* release_int_list();
  ::pg_query::IntList* mutable_int_list();
  void set_allocated_int_list(::pg_query::IntList* int_list);
  private:
  const ::pg_query::IntList& _internal_int_list() const;
  ::pg_query::IntList* _internal_mutable_int_list();
  public:
  void unsafe_arena_set_allocated_int_list(
      ::pg_query::IntList* int_list);
  ::pg_query::IntList* unsafe_arena_release_int_list();

  // .pg_query.OidList oid_list = 228 [json_name = "OidList"];
  bool has_oid_list() const;
  private:
  bool _internal_has_oid_list() const;
  public:
  void clear_oid_list();
  const ::pg_query::OidList& oid_list() const;
  ::pg_query::OidList* release_oid_list();
  ::pg_query::OidList* mutable_oid_list();
  void set_allocated_oid_list(::pg_query::OidList* oid_list);
  private:
  const ::pg_query::OidList& _internal_oid_list() const;
  ::pg_query::OidList* _internal_mutable_oid_list();
  public:
  void unsafe_arena_set_allocated_oid_list(
      ::pg_query::OidList* oid_list);
  ::pg_query::OidList* unsafe_arena_release_oid_list();

  void clear_node();
  NodeCase node_case() const;
  // @@protoc_insertion_point(class_scope:pg_query.Node)
 private:
  class _Internal;
  void set_has_alias();
  void set_has_range_var();
  void set_has_table_func();
  void set_has_expr();
  void set_has_var();
  void set_has_param();
  void set_has_aggref();
  void set_has_grouping_func();
  void set_has_window_func();
  void set_has_subscripting_ref();
  void set_has_func_expr();
  void set_has_named_arg_expr();
  void set_has_op_expr();
  void set_has_distinct_expr();
  void set_has_null_if_expr();
  void set_has_scalar_array_op_expr();
  void set_has_bool_expr();
  void set_has_sub_link();
  void set_has_sub_plan();
  void set_has_alternative_sub_plan();
  void set_has_field_select();
  void set_has_field_store();
  void set_has_relabel_type();
  void set_has_coerce_via_io();
  void set_has_array_coerce_expr();
  void set_has_convert_rowtype_expr();
  void set_has_collate_expr();
  void set_has_case_expr();
  void set_has_case_when();
  void set_has_case_test_expr();
  void set_has_array_expr();
  void set_has_row_expr();
  void set_has_row_compare_expr();
  void set_has_coalesce_expr();
  void set_has_min_max_expr();
  void set_has_sqlvalue_function();
  void set_has_xml_expr();
  void set_has_null_test();
  void set_has_boolean_test();
  void set_has_coerce_to_domain();
  void set_has_coerce_to_domain_value();
  void set_has_set_to_default();
  void set_has_current_of_expr();
  void set_has_next_value_expr();
  void set_has_inference_elem();
  void set_has_target_entry();
  void set_has_range_tbl_ref();
  void set_has_join_expr();
  void set_has_from_expr();
  void set_has_on_conflict_expr();
  void set_has_into_clause();
  void set_has_raw_stmt();
  void set_has_query();
  void set_has_insert_stmt();
  void set_has_delete_stmt();
  void set_has_update_stmt();
  void set_has_select_stmt();
  void set_has_alter_table_stmt();
  void set_has_alter_table_cmd();
  void set_has_alter_domain_stmt();
  void set_has_set_operation_stmt();
  void set_has_grant_stmt();
  void set_has_grant_role_stmt();
  void set_has_alter_default_privileges_stmt();
  void set_has_close_portal_stmt();
  void set_has_cluster_stmt();
  void set_has_copy_stmt();
  void set_has_create_stmt();
  void set_has_define_stmt();
  void set_has_drop_stmt();
  void set_has_truncate_stmt();
  void set_has_comment_stmt();
  void set_has_fetch_stmt();
  void set_has_index_stmt();
  void set_has_create_function_stmt();
  void set_has_alter_function_stmt();
  void set_has_do_stmt();
  void set_has_rename_stmt();
  void set_has_rule_stmt();
  void set_has_notify_stmt();
  void set_has_listen_stmt();
  void set_has_unlisten_stmt();
  void set_has_transaction_stmt();
  void set_has_view_stmt();
  void set_has_load_stmt();
  void set_has_create_domain_stmt();
  void set_has_createdb_stmt();
  void set_has_dropdb_stmt();
  void set_has_vacuum_stmt();
  void set_has_explain_stmt();
  void set_has_create_table_as_stmt();
  void set_has_create_seq_stmt();
  void set_has_alter_seq_stmt();
  void set_has_variable_set_stmt();
  void set_has_variable_show_stmt();
  void set_has_discard_stmt();
  void set_has_create_trig_stmt();
  void set_has_create_plang_stmt();
  void set_has_create_role_stmt();
  void set_has_alter_role_stmt();
  void set_has_drop_role_stmt();
  void set_has_lock_stmt();
  void set_has_constraints_set_stmt();
  void set_has_reindex_stmt();
  void set_has_check_point_stmt();
  void set_has_create_schema_stmt();
  void set_has_alter_database_stmt();
  void set_has_alter_database_set_stmt();
  void set_has_alter_role_set_stmt();
  void set_has_create_conversion_stmt();
  void set_has_create_cast_stmt();
  void set_has_create_op_class_stmt();
  void set_has_create_op_family_stmt();
  void set_has_alter_op_family_stmt();
  void set_has_prepare_stmt();
  void set_has_execute_stmt();
  void set_has_deallocate_stmt();
  void set_has_declare_cursor_stmt();
  void set_has_create_table_space_stmt();
  void set_has_drop_table_space_stmt();
  void set_has_alter_object_depends_stmt();
  void set_has_alter_object_schema_stmt();
  void set_has_alter_owner_stmt();
  void set_has_alter_operator_stmt();
  void set_has_alter_type_stmt();
  void set_has_drop_owned_stmt();
  void set_has_reassign_owned_stmt();
  void set_has_composite_type_stmt();
  void set_has_create_enum_stmt();
  void set_has_create_range_stmt();
  void set_has_alter_enum_stmt();
  void set_has_alter_tsdictionary_stmt();
  void set_has_alter_tsconfiguration_stmt();
  void set_has_create_fdw_stmt();
  void set_has_alter_fdw_stmt();
  void set_has_create_foreign_server_stmt();
  void set_has_alter_foreign_server_stmt();
  void set_has_create_user_mapping_stmt();
  void set_has_alter_user_mapping_stmt();
  void set_has_drop_user_mapping_stmt();
  void set_has_alter_table_space_options_stmt();
  void set_has_alter_table_move_all_stmt();
  void set_has_sec_label_stmt();
  void set_has_create_foreign_table_stmt();
  void set_has_import_foreign_schema_stmt();
  void set_has_create_extension_stmt();
  void set_has_alter_extension_stmt();
  void set_has_alter_extension_contents_stmt();
  void set_has_create_event_trig_stmt();
  void set_has_alter_event_trig_stmt();
  void set_has_refresh_mat_view_stmt();
  void set_has_replica_identity_stmt();
  void set_has_alter_system_stmt();
  void set_has_create_policy_stmt();
  void set_has_alter_policy_stmt();
  void set_has_create_transform_stmt();
  void set_has_create_am_stmt();
  void set_has_create_publication_stmt();
  void set_has_alter_publication_stmt();
  void set_has_create_subscription_stmt();
  void set_has_alter_subscription_stmt();
  void set_has_drop_subscription_stmt();
  void set_has_create_stats_stmt();
  void set_has_alter_collation_stmt();
  void set_has_call_stmt();
  void set_has_alter_stats_stmt();
  void set_has_a_expr();
  void set_has_column_ref();
  void set_has_param_ref();
  void set_has_a_const();
  void set_has_func_call();
  void set_has_a_star();
  void set_has_a_indices();
  void set_has_a_indirection();
  void set_has_a_array_expr();
  void set_has_res_target();
  void set_has_multi_assign_ref();
  void set_has_type_cast();
  void set_has_collate_clause();
  void set_has_sort_by();
  void set_has_window_def();
  void set_has_range_subselect();
  void set_has_range_function();
  void set_has_range_table_sample();
  void set_has_range_table_func();
  void set_has_range_table_func_col();
  void set_has_type_name();
  void set_has_column_def();
  void set_has_index_elem();
  void set_has_constraint();
  void set_has_def_elem();
  void set_has_range_tbl_entry();
  void set_has_range_tbl_function();
  void set_has_table_sample_clause();
  void set_has_with_check_option();
  void set_has_sort_group_clause();
  void set_has_grouping_set();
  void set_has_window_clause();
  void set_has_object_with_args();
  void set_has_access_priv();
  void set_has_create_op_class_item();
  void set_has_table_like_clause();
  void set_has_function_parameter();
  void set_has_locking_clause();
  void set_has_row_mark_clause();
  void set_has_xml_serialize();
  void set_has_with_clause();
  void set_has_infer_clause();
  void set_has_on_conflict_clause();
  void set_has_common_table_expr();
  void set_has_role_spec();
  void set_has_trigger_transition();
  void set_has_partition_elem();
  void set_has_partition_spec();
  void set_has_partition_bound_spec();
  void set_has_partition_range_datum();
  void set_has_partition_cmd();
  void set_has_vacuum_relation();
  void set_has_inline_code_block();
  void set_has_call_context();
  void set_has_integer();
  void set_has_float_();
  void set_has_string();
  void set_has_bit_string();
  void set_has_null();
  void set_has_list();
  void set_has_int_list();
  void set_has_oid_list();

  inline bool has_node() const;
  inline void clear_has_node();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  union NodeUnion {
    NodeUnion() {}
    ::pg_query::Alias* alias_;
    ::pg_query::RangeVar* range_var_;
    ::pg_query::TableFunc* table_func_;
    ::pg_query::Expr* expr_;
    ::pg_query::Var* var_;
    ::pg_query::Param* param_;
    ::pg_query::Aggref* aggref_;
    ::pg_query::GroupingFunc* grouping_func_;
    ::pg_query::WindowFunc* window_func_;
    ::pg_query::SubscriptingRef* subscripting_ref_;
    ::pg_query::FuncExpr* func_expr_;
    ::pg_query::NamedArgExpr* named_arg_expr_;
    ::pg_query::OpExpr* op_expr_;
    ::pg_query::DistinctExpr* distinct_expr_;
    ::pg_query::NullIfExpr* null_if_expr_;
    ::pg_query::ScalarArrayOpExpr* scalar_array_op_expr_;
    ::pg_query::BoolExpr* bool_expr_;
    ::pg_query::SubLink* sub_link_;
    ::pg_query::SubPlan* sub_plan_;
    ::pg_query::AlternativeSubPlan* alternative_sub_plan_;
    ::pg_query::FieldSelect* field_select_;
    ::pg_query::FieldStore* field_store_;
    ::pg_query::RelabelType* relabel_type_;
    ::pg_query::CoerceViaIO* coerce_via_io_;
    ::pg_query::ArrayCoerceExpr* array_coerce_expr_;
    ::pg_query::ConvertRowtypeExpr* convert_rowtype_expr_;
    ::pg_query::CollateExpr* collate_expr_;
    ::pg_query::CaseExpr* case_expr_;
    ::pg_query::CaseWhen* case_when_;
    ::pg_query::CaseTestExpr* case_test_expr_;
    ::pg_query::ArrayExpr* array_expr_;
    ::pg_query::RowExpr* row_expr_;
    ::pg_query::RowCompareExpr* row_compare_expr_;
    ::pg_query::CoalesceExpr* coalesce_expr_;
    ::pg_query::MinMaxExpr* min_max_expr_;
    ::pg_query::SQLValueFunction* sqlvalue_function_;
    ::pg_query::XmlExpr* xml_expr_;
    ::pg_query::NullTest* null_test_;
    ::pg_query::BooleanTest* boolean_test_;
    ::pg_query::CoerceToDomain* coerce_to_domain_;
    ::pg_query::CoerceToDomainValue* coerce_to_domain_value_;
    ::pg_query::SetToDefault* set_to_default_;
    ::pg_query::CurrentOfExpr* current_of_expr_;
    ::pg_query::NextValueExpr* next_value_expr_;
    ::pg_query::InferenceElem* inference_elem_;
    ::pg_query::TargetEntry* target_entry_;
    ::pg_query::RangeTblRef* range_tbl_ref_;
    ::pg_query::JoinExpr* join_expr_;
    ::pg_query::FromExpr* from_expr_;
    ::pg_query::OnConflictExpr* on_conflict_expr_;
    ::pg_query::IntoClause* into_clause_;
    ::pg_query::RawStmt* raw_stmt_;
    ::pg_query::Query* query_;
    ::pg_query::InsertStmt* insert_stmt_;
    ::pg_query::DeleteStmt* delete_stmt_;
    ::pg_query::UpdateStmt* update_stmt_;
    ::pg_query::SelectStmt* select_stmt_;
    ::pg_query::AlterTableStmt* alter_table_stmt_;
    ::pg_query::AlterTableCmd* alter_table_cmd_;
    ::pg_query::AlterDomainStmt* alter_domain_stmt_;
    ::pg_query::SetOperationStmt* set_operation_stmt_;
    ::pg_query::GrantStmt* grant_stmt_;
    ::pg_query::GrantRoleStmt* grant_role_stmt_;
    ::pg_query::AlterDefaultPrivilegesStmt* alter_default_privileges_stmt_;
    ::pg_query::ClosePortalStmt* close_portal_stmt_;
    ::pg_query::ClusterStmt* cluster_stmt_;
    ::pg_query::CopyStmt* copy_stmt_;
    ::pg_query::CreateStmt* create_stmt_;
    ::pg_query::DefineStmt* define_stmt_;
    ::pg_query::DropStmt* drop_stmt_;
    ::pg_query::TruncateStmt* truncate_stmt_;
    ::pg_query::CommentStmt* comment_stmt_;
    ::pg_query::FetchStmt* fetch_stmt_;
    ::pg_query::IndexStmt* index_stmt_;
    ::pg_query::CreateFunctionStmt* create_function_stmt_;
    ::pg_query::AlterFunctionStmt* alter_function_stmt_;
    ::pg_query::DoStmt* do_stmt_;
    ::pg_query::RenameStmt* rename_stmt_;
    ::pg_query::RuleStmt* rule_stmt_;
    ::pg_query::NotifyStmt* notify_stmt_;
    ::pg_query::ListenStmt* listen_stmt_;
    ::pg_query::UnlistenStmt* unlisten_stmt_;
    ::pg_query::TransactionStmt* transaction_stmt_;
    ::pg_query::ViewStmt* view_stmt_;
    ::pg_query::LoadStmt* load_stmt_;
    ::pg_query::CreateDomainStmt* create_domain_stmt_;
    ::pg_query::CreatedbStmt* createdb_stmt_;
    ::pg_query::DropdbStmt* dropdb_stmt_;
    ::pg_query::VacuumStmt* vacuum_stmt_;
    ::pg_query::ExplainStmt* explain_stmt_;
    ::pg_query::CreateTableAsStmt* create_table_as_stmt_;
    ::pg_query::CreateSeqStmt* create_seq_stmt_;
    ::pg_query::AlterSeqStmt* alter_seq_stmt_;
    ::pg_query::VariableSetStmt* variable_set_stmt_;
    ::pg_query::VariableShowStmt* variable_show_stmt_;
    ::pg_query::DiscardStmt* discard_stmt_;
    ::pg_query::CreateTrigStmt* create_trig_stmt_;
    ::pg_query::CreatePLangStmt* create_plang_stmt_;
    ::pg_query::CreateRoleStmt* create_role_stmt_;
    ::pg_query::AlterRoleStmt* alter_role_stmt_;
    ::pg_query::DropRoleStmt* drop_role_stmt_;
    ::pg_query::LockStmt* lock_stmt_;
    ::pg_query::ConstraintsSetStmt* constraints_set_stmt_;
    ::pg_query::ReindexStmt* reindex_stmt_;
    ::pg_query::CheckPointStmt* check_point_stmt_;
    ::pg_query::CreateSchemaStmt* create_schema_stmt_;
    ::pg_query::AlterDatabaseStmt* alter_database_stmt_;
    ::pg_query::AlterDatabaseSetStmt* alter_database_set_stmt_;
    ::pg_query::AlterRoleSetStmt* alter_role_set_stmt_;
    ::pg_query::CreateConversionStmt* create_conversion_stmt_;
    ::pg_query::CreateCastStmt* create_cast_stmt_;
    ::pg_query::CreateOpClassStmt* create_op_class_stmt_;
    ::pg_query::CreateOpFamilyStmt* create_op_family_stmt_;
    ::pg_query::AlterOpFamilyStmt* alter_op_family_stmt_;
    ::pg_query::PrepareStmt* prepare_stmt_;
    ::pg_query::ExecuteStmt* execute_stmt_;
    ::pg_query::DeallocateStmt* deallocate_stmt_;
    ::pg_query::DeclareCursorStmt* declare_cursor_stmt_;
    ::pg_query::CreateTableSpaceStmt* create_table_space_stmt_;
    ::pg_query::DropTableSpaceStmt* drop_table_space_stmt_;
    ::pg_query::AlterObjectDependsStmt* alter_object_depends_stmt_;
    ::pg_query::AlterObjectSchemaStmt* alter_object_schema_stmt_;
    ::pg_query::AlterOwnerStmt* alter_owner_stmt_;
    ::pg_query::AlterOperatorStmt* alter_operator_stmt_;
    ::pg_query::AlterTypeStmt* alter_type_stmt_;
    ::pg_query::DropOwnedStmt* drop_owned_stmt_;
    ::pg_query::ReassignOwnedStmt* reassign_owned_stmt_;
    ::pg_query::CompositeTypeStmt* composite_type_stmt_;
    ::pg_query::CreateEnumStmt* create_enum_stmt_;
    ::pg_query::CreateRangeStmt* create_range_stmt_;
    ::pg_query::AlterEnumStmt* alter_enum_stmt_;
    ::pg_query::AlterTSDictionaryStmt* alter_tsdictionary_stmt_;
    ::pg_query::AlterTSConfigurationStmt* alter_tsconfiguration_stmt_;
    ::pg_query::CreateFdwStmt* create_fdw_stmt_;
    ::pg_query::AlterFdwStmt* alter_fdw_stmt_;
    ::pg_query::CreateForeignServerStmt* create_foreign_server_stmt_;
    ::pg_query::AlterForeignServerStmt* alter_foreign_server_stmt_;
    ::pg_query::CreateUserMappingStmt* create_user_mapping_stmt_;
    ::pg_query::AlterUserMappingStmt* alter_user_mapping_stmt_;
    ::pg_query::DropUserMappingStmt* drop_user_mapping_stmt_;
    ::pg_query::AlterTableSpaceOptionsStmt* alter_table_space_options_stmt_;
    ::pg_query::AlterTableMoveAllStmt* alter_table_move_all_stmt_;
    ::pg_query::SecLabelStmt* sec_label_stmt_;
    ::pg_query::CreateForeignTableStmt* create_foreign_table_stmt_;
    ::pg_query::ImportForeignSchemaStmt* import_foreign_schema_stmt_;
    ::pg_query::CreateExtensionStmt* create_extension_stmt_;
    ::pg_query::AlterExtensionStmt* alter_extension_stmt_;
    ::pg_query::AlterExtensionContentsStmt* alter_extension_contents_stmt_;
    ::pg_query::CreateEventTrigStmt* create_event_trig_stmt_;
    ::pg_query::AlterEventTrigStmt* alter_event_trig_stmt_;
    ::pg_query::RefreshMatViewStmt* refresh_mat_view_stmt_;
    ::pg_query::ReplicaIdentityStmt* replica_identity_stmt_;
    ::pg_query::AlterSystemStmt* alter_system_stmt_;
    ::pg_query::CreatePolicyStmt* create_policy_stmt_;
    ::pg_query::AlterPolicyStmt* alter_policy_stmt_;
    ::pg_query::CreateTransformStmt* create_transform_stmt_;
    ::pg_query::CreateAmStmt* create_am_stmt_;
    ::pg_query::CreatePublicationStmt* create_publication_stmt_;
    ::pg_query::AlterPublicationStmt* alter_publication_stmt_;
    ::pg_query::CreateSubscriptionStmt* create_subscription_stmt_;
    ::pg_query::AlterSubscriptionStmt* alter_subscription_stmt_;
    ::pg_query::DropSubscriptionStmt* drop_subscription_stmt_;
    ::pg_query::CreateStatsStmt* create_stats_stmt_;
    ::pg_query::AlterCollationStmt* alter_collation_stmt_;
    ::pg_query::CallStmt* call_stmt_;
    ::pg_query::AlterStatsStmt* alter_stats_stmt_;
    ::pg_query::A_Expr* a_expr_;
    ::pg_query::ColumnRef* column_ref_;
    ::pg_query::ParamRef* param_ref_;
    ::pg_query::A_Const* a_const_;
    ::pg_query::FuncCall* func_call_;
    ::pg_query::A_Star* a_star_;
    ::pg_query::A_Indices* a_indices_;
    ::pg_query::A_Indirection* a_indirection_;
    ::pg_query::A_ArrayExpr* a_array_expr_;
    ::pg_query::ResTarget* res_target_;
    ::pg_query::MultiAssignRef* multi_assign_ref_;
    ::pg_query::TypeCast* type_cast_;
    ::pg_query::CollateClause* collate_clause_;
    ::pg_query::SortBy* sort_by_;
    ::pg_query::WindowDef* window_def_;
    ::pg_query::RangeSubselect* range_subselect_;
    ::pg_query::RangeFunction* range_function_;
    ::pg_query::RangeTableSample* range_table_sample_;
    ::pg_query::RangeTableFunc* range_table_func_;
    ::pg_query::RangeTableFuncCol* range_table_func_col_;
    ::pg_query::TypeName* type_name_;
    ::pg_query::ColumnDef* column_def_;
    ::pg_query::IndexElem* index_elem_;
    ::pg_query::Constraint* constraint_;
    ::pg_query::DefElem* def_elem_;
    ::pg_query::RangeTblEntry* range_tbl_entry_;
    ::pg_query::RangeTblFunction* range_tbl_function_;
    ::pg_query::TableSampleClause* table_sample_clause_;
    ::pg_query::WithCheckOption* with_check_option_;
    ::pg_query::SortGroupClause* sort_group_clause_;
    ::pg_query::GroupingSet* grouping_set_;
    ::pg_query::WindowClause* window_clause_;
    ::pg_query::ObjectWithArgs* object_with_args_;
    ::pg_query::AccessPriv* access_priv_;
    ::pg_query::CreateOpClassItem* create_op_class_item_;
    ::pg_query::TableLikeClause* table_like_clause_;
    ::pg_query::FunctionParameter* function_parameter_;
    ::pg_query::LockingClause* locking_clause_;
    ::pg_query::RowMarkClause* row_mark_clause_;
    ::pg_query::XmlSerialize* xml_serialize_;
    ::pg_query::WithClause* with_clause_;
    ::pg_query::InferClause* infer_clause_;
    ::pg_query::OnConflictClause* on_conflict_clause_;
    ::pg_query::CommonTableExpr* common_table_expr_;
    ::pg_query::RoleSpec* role_spec_;
    ::pg_query::TriggerTransition* trigger_transition_;
    ::pg_query::PartitionElem* partition_elem_;
    ::pg_query::PartitionSpec* partition_spec_;
    ::pg_query::PartitionBoundSpec* partition_bound_spec_;
    ::pg_query::PartitionRangeDatum* partition_range_datum_;
    ::pg_query::PartitionCmd* partition_cmd_;
    ::pg_query::VacuumRelation* vacuum_relation_;
    ::pg_query::InlineCodeBlock* inline_code_block_;
    ::pg_query::CallContext* call_context_;
    ::pg_query::Integer* integer_;
    ::pg_query::Float* float__;
    ::pg_query::String* string_;
    ::pg_query::BitString* bit_string_;
    ::pg_query::Null* null_;
    ::pg_query::List* list_;
    ::pg_query::IntList* int_list_;
    ::pg_query::OidList* oid_list_;
  } node_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class Integer PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Integer) */ {
 public:
  inline Integer() : Integer(nullptr) {}
  virtual ~Integer();

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

  inline Integer& operator=(const Integer& from) {
    CopyFrom(from);
    return *this;
  }
  inline Integer& operator=(Integer&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Integer& default_instance();

  static inline const Integer* internal_default_instance() {
    return reinterpret_cast<const Integer*>(
               &_Integer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(Integer& a, Integer& b) {
    a.Swap(&b);
  }
  inline void Swap(Integer* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Integer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Integer* New() const final {
    return CreateMaybeMessage<Integer>(nullptr);
  }

  Integer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Integer>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Integer& from);
  void MergeFrom(const Integer& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Integer* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.Integer";
  }
  protected:
  explicit Integer(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIvalFieldNumber = 1,
  };
  // int32 ival = 1;
  void clear_ival();
  ::PROTOBUF_NAMESPACE_ID::int32 ival() const;
  void set_ival(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_ival() const;
  void _internal_set_ival(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.Integer)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int32 ival_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class Float PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Float) */ {
 public:
  inline Float() : Float(nullptr) {}
  virtual ~Float();

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

  inline Float& operator=(const Float& from) {
    CopyFrom(from);
    return *this;
  }
  inline Float& operator=(Float&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Float& default_instance();

  static inline const Float* internal_default_instance() {
    return reinterpret_cast<const Float*>(
               &_Float_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(Float& a, Float& b) {
    a.Swap(&b);
  }
  inline void Swap(Float* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Float* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Float* New() const final {
    return CreateMaybeMessage<Float>(nullptr);
  }

  Float* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Float>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Float& from);
  void MergeFrom(const Float& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Float* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.Float";
  }
  protected:
  explicit Float(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kStrFieldNumber = 1,
  };
  // string str = 1;
  void clear_str();
  const std::string& str() const;
  void set_str(const std::string& value);
  void set_str(std::string&& value);
  void set_str(const char* value);
  void set_str(const char* value, size_t size);
  std::string* mutable_str();
  std::string* release_str();
  void set_allocated_str(std::string* str);
  private:
  const std::string& _internal_str() const;
  void _internal_set_str(const std::string& value);
  std::string* _internal_mutable_str();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.Float)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr str_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class String PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.String) */ {
 public:
  inline String() : String(nullptr) {}
  virtual ~String();

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

  inline String& operator=(const String& from) {
    CopyFrom(from);
    return *this;
  }
  inline String& operator=(String&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const String& default_instance();

  static inline const String* internal_default_instance() {
    return reinterpret_cast<const String*>(
               &_String_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(String& a, String& b) {
    a.Swap(&b);
  }
  inline void Swap(String* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(String* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline String* New() const final {
    return CreateMaybeMessage<String>(nullptr);
  }

  String* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<String>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const String& from);
  void MergeFrom(const String& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(String* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.String";
  }
  protected:
  explicit String(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kStrFieldNumber = 1,
  };
  // string str = 1;
  void clear_str();
  const std::string& str() const;
  void set_str(const std::string& value);
  void set_str(std::string&& value);
  void set_str(const char* value);
  void set_str(const char* value, size_t size);
  std::string* mutable_str();
  std::string* release_str();
  void set_allocated_str(std::string* str);
  private:
  const std::string& _internal_str() const;
  void _internal_set_str(const std::string& value);
  std::string* _internal_mutable_str();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.String)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr str_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class BitString PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.BitString) */ {
 public:
  inline BitString() : BitString(nullptr) {}
  virtual ~BitString();

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

  inline BitString& operator=(const BitString& from) {
    CopyFrom(from);
    return *this;
  }
  inline BitString& operator=(BitString&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const BitString& default_instance();

  static inline const BitString* internal_default_instance() {
    return reinterpret_cast<const BitString*>(
               &_BitString_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(BitString& a, BitString& b) {
    a.Swap(&b);
  }
  inline void Swap(BitString* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BitString* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline BitString* New() const final {
    return CreateMaybeMessage<BitString>(nullptr);
  }

  BitString* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BitString>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BitString& from);
  void MergeFrom(const BitString& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BitString* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.BitString";
  }
  protected:
  explicit BitString(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kStrFieldNumber = 1,
  };
  // string str = 1;
  void clear_str();
  const std::string& str() const;
  void set_str(const std::string& value);
  void set_str(std::string&& value);
  void set_str(const char* value);
  void set_str(const char* value, size_t size);
  std::string* mutable_str();
  std::string* release_str();
  void set_allocated_str(std::string* str);
  private:
  const std::string& _internal_str() const;
  void _internal_set_str(const std::string& value);
  std::string* _internal_mutable_str();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.BitString)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr str_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class Null PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Null) */ {
 public:
  inline Null() : Null(nullptr) {}
  virtual ~Null();

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

  inline Null& operator=(const Null& from) {
    CopyFrom(from);
    return *this;
  }
  inline Null& operator=(Null&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Null& default_instance();

  static inline const Null* internal_default_instance() {
    return reinterpret_cast<const Null*>(
               &_Null_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(Null& a, Null& b) {
    a.Swap(&b);
  }
  inline void Swap(Null* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Null* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Null* New() const final {
    return CreateMaybeMessage<Null>(nullptr);
  }

  Null* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Null>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Null& from);
  void MergeFrom(const Null& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Null* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.Null";
  }
  protected:
  explicit Null(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // @@protoc_insertion_point(class_scope:pg_query.Null)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class List PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.List) */ {
 public:
  inline List() : List(nullptr) {}
  virtual ~List();

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

  inline List& operator=(const List& from) {
    CopyFrom(from);
    return *this;
  }
  inline List& operator=(List&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const List& default_instance();

  static inline const List* internal_default_instance() {
    return reinterpret_cast<const List*>(
               &_List_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(List& a, List& b) {
    a.Swap(&b);
  }
  inline void Swap(List* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(List* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline List* New() const final {
    return CreateMaybeMessage<List>(nullptr);
  }

  List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<List>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const List& from);
  void MergeFrom(const List& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(List* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.List";
  }
  protected:
  explicit List(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kItemsFieldNumber = 1,
  };
  // repeated .pg_query.Node items = 1;
  int items_size() const;
  private:
  int _internal_items_size() const;
  public:
  void clear_items();
  ::pg_query::Node* mutable_items(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_items();
  private:
  const ::pg_query::Node& _internal_items(int index) const;
  ::pg_query::Node* _internal_add_items();
  public:
  const ::pg_query::Node& items(int index) const;
  ::pg_query::Node* add_items();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      items() const;

  // @@protoc_insertion_point(class_scope:pg_query.List)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > items_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class OidList PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.OidList) */ {
 public:
  inline OidList() : OidList(nullptr) {}
  virtual ~OidList();

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

  inline OidList& operator=(const OidList& from) {
    CopyFrom(from);
    return *this;
  }
  inline OidList& operator=(OidList&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const OidList& default_instance();

  static inline const OidList* internal_default_instance() {
    return reinterpret_cast<const OidList*>(
               &_OidList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(OidList& a, OidList& b) {
    a.Swap(&b);
  }
  inline void Swap(OidList* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OidList* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline OidList* New() const final {
    return CreateMaybeMessage<OidList>(nullptr);
  }

  OidList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<OidList>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const OidList& from);
  void MergeFrom(const OidList& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OidList* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.OidList";
  }
  protected:
  explicit OidList(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kItemsFieldNumber = 1,
  };
  // repeated .pg_query.Node items = 1;
  int items_size() const;
  private:
  int _internal_items_size() const;
  public:
  void clear_items();
  ::pg_query::Node* mutable_items(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_items();
  private:
  const ::pg_query::Node& _internal_items(int index) const;
  ::pg_query::Node* _internal_add_items();
  public:
  const ::pg_query::Node& items(int index) const;
  ::pg_query::Node* add_items();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      items() const;

  // @@protoc_insertion_point(class_scope:pg_query.OidList)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > items_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class IntList PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.IntList) */ {
 public:
  inline IntList() : IntList(nullptr) {}
  virtual ~IntList();

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

  inline IntList& operator=(const IntList& from) {
    CopyFrom(from);
    return *this;
  }
  inline IntList& operator=(IntList&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const IntList& default_instance();

  static inline const IntList* internal_default_instance() {
    return reinterpret_cast<const IntList*>(
               &_IntList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(IntList& a, IntList& b) {
    a.Swap(&b);
  }
  inline void Swap(IntList* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IntList* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline IntList* New() const final {
    return CreateMaybeMessage<IntList>(nullptr);
  }

  IntList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<IntList>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const IntList& from);
  void MergeFrom(const IntList& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(IntList* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.IntList";
  }
  protected:
  explicit IntList(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kItemsFieldNumber = 1,
  };
  // repeated .pg_query.Node items = 1;
  int items_size() const;
  private:
  int _internal_items_size() const;
  public:
  void clear_items();
  ::pg_query::Node* mutable_items(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_items();
  private:
  const ::pg_query::Node& _internal_items(int index) const;
  ::pg_query::Node* _internal_add_items();
  public:
  const ::pg_query::Node& items(int index) const;
  ::pg_query::Node* add_items();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      items() const;

  // @@protoc_insertion_point(class_scope:pg_query.IntList)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > items_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class Bitmapset PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Bitmapset) */ {
 public:
  inline Bitmapset() : Bitmapset(nullptr) {}
  virtual ~Bitmapset();

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

  inline Bitmapset& operator=(const Bitmapset& from) {
    CopyFrom(from);
    return *this;
  }
  inline Bitmapset& operator=(Bitmapset&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Bitmapset& default_instance();

  static inline const Bitmapset* internal_default_instance() {
    return reinterpret_cast<const Bitmapset*>(
               &_Bitmapset_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(Bitmapset& a, Bitmapset& b) {
    a.Swap(&b);
  }
  inline void Swap(Bitmapset* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Bitmapset* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Bitmapset* New() const final {
    return CreateMaybeMessage<Bitmapset>(nullptr);
  }

  Bitmapset* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Bitmapset>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Bitmapset& from);
  void MergeFrom(const Bitmapset& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Bitmapset* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.Bitmapset";
  }
  protected:
  explicit Bitmapset(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kWordsFieldNumber = 1,
  };
  // repeated uint64 words = 1;
  int words_size() const;
  private:
  int _internal_words_size() const;
  public:
  void clear_words();
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_words(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
      _internal_words() const;
  void _internal_add_words(::PROTOBUF_NAMESPACE_ID::uint64 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
      _internal_mutable_words();
  public:
  ::PROTOBUF_NAMESPACE_ID::uint64 words(int index) const;
  void set_words(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value);
  void add_words(::PROTOBUF_NAMESPACE_ID::uint64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
      words() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
      mutable_words();

  // @@protoc_insertion_point(class_scope:pg_query.Bitmapset)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 > words_;
  mutable std::atomic<int> _words_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class Alias PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Alias) */ {
 public:
  inline Alias() : Alias(nullptr) {}
  virtual ~Alias();

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

  inline Alias& operator=(const Alias& from) {
    CopyFrom(from);
    return *this;
  }
  inline Alias& operator=(Alias&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Alias& default_instance();

  static inline const Alias* internal_default_instance() {
    return reinterpret_cast<const Alias*>(
               &_Alias_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(Alias& a, Alias& b) {
    a.Swap(&b);
  }
  inline void Swap(Alias* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Alias* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Alias* New() const final {
    return CreateMaybeMessage<Alias>(nullptr);
  }

  Alias* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Alias>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Alias& from);
  void MergeFrom(const Alias& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Alias* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.Alias";
  }
  protected:
  explicit Alias(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kColnamesFieldNumber = 2,
    kAliasnameFieldNumber = 1,
  };
  // repeated .pg_query.Node colnames = 2 [json_name = "colnames"];
  int colnames_size() const;
  private:
  int _internal_colnames_size() const;
  public:
  void clear_colnames();
  ::pg_query::Node* mutable_colnames(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_colnames();
  private:
  const ::pg_query::Node& _internal_colnames(int index) const;
  ::pg_query::Node* _internal_add_colnames();
  public:
  const ::pg_query::Node& colnames(int index) const;
  ::pg_query::Node* add_colnames();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      colnames() const;

  // string aliasname = 1 [json_name = "aliasname"];
  void clear_aliasname();
  const std::string& aliasname() const;
  void set_aliasname(const std::string& value);
  void set_aliasname(std::string&& value);
  void set_aliasname(const char* value);
  void set_aliasname(const char* value, size_t size);
  std::string* mutable_aliasname();
  std::string* release_aliasname();
  void set_allocated_aliasname(std::string* aliasname);
  private:
  const std::string& _internal_aliasname() const;
  void _internal_set_aliasname(const std::string& value);
  std::string* _internal_mutable_aliasname();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.Alias)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > colnames_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aliasname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RangeVar PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeVar) */ {
 public:
  inline RangeVar() : RangeVar(nullptr) {}
  virtual ~RangeVar();

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

  inline RangeVar& operator=(const RangeVar& from) {
    CopyFrom(from);
    return *this;
  }
  inline RangeVar& operator=(RangeVar&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RangeVar& default_instance();

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

  friend void swap(RangeVar& a, RangeVar& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeVar* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeVar* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline RangeVar* New() const final {
    return CreateMaybeMessage<RangeVar>(nullptr);
  }

  RangeVar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RangeVar>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RangeVar& from);
  void MergeFrom(const RangeVar& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RangeVar* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RangeVar";
  }
  protected:
  explicit RangeVar(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCatalognameFieldNumber = 1,
    kSchemanameFieldNumber = 2,
    kRelnameFieldNumber = 3,
    kRelpersistenceFieldNumber = 5,
    kAliasFieldNumber = 6,
    kInhFieldNumber = 4,
    kLocationFieldNumber = 7,
  };
  // string catalogname = 1 [json_name = "catalogname"];
  void clear_catalogname();
  const std::string& catalogname() const;
  void set_catalogname(const std::string& value);
  void set_catalogname(std::string&& value);
  void set_catalogname(const char* value);
  void set_catalogname(const char* value, size_t size);
  std::string* mutable_catalogname();
  std::string* release_catalogname();
  void set_allocated_catalogname(std::string* catalogname);
  private:
  const std::string& _internal_catalogname() const;
  void _internal_set_catalogname(const std::string& value);
  std::string* _internal_mutable_catalogname();
  public:

  // string schemaname = 2 [json_name = "schemaname"];
  void clear_schemaname();
  const std::string& schemaname() const;
  void set_schemaname(const std::string& value);
  void set_schemaname(std::string&& value);
  void set_schemaname(const char* value);
  void set_schemaname(const char* value, size_t size);
  std::string* mutable_schemaname();
  std::string* release_schemaname();
  void set_allocated_schemaname(std::string* schemaname);
  private:
  const std::string& _internal_schemaname() const;
  void _internal_set_schemaname(const std::string& value);
  std::string* _internal_mutable_schemaname();
  public:

  // string relname = 3 [json_name = "relname"];
  void clear_relname();
  const std::string& relname() const;
  void set_relname(const std::string& value);
  void set_relname(std::string&& value);
  void set_relname(const char* value);
  void set_relname(const char* value, size_t size);
  std::string* mutable_relname();
  std::string* release_relname();
  void set_allocated_relname(std::string* relname);
  private:
  const std::string& _internal_relname() const;
  void _internal_set_relname(const std::string& value);
  std::string* _internal_mutable_relname();
  public:

  // string relpersistence = 5 [json_name = "relpersistence"];
  void clear_relpersistence();
  const std::string& relpersistence() const;
  void set_relpersistence(const std::string& value);
  void set_relpersistence(std::string&& value);
  void set_relpersistence(const char* value);
  void set_relpersistence(const char* value, size_t size);
  std::string* mutable_relpersistence();
  std::string* release_relpersistence();
  void set_allocated_relpersistence(std::string* relpersistence);
  private:
  const std::string& _internal_relpersistence() const;
  void _internal_set_relpersistence(const std::string& value);
  std::string* _internal_mutable_relpersistence();
  public:

  // .pg_query.Alias alias = 6 [json_name = "alias"];
  bool has_alias() const;
  private:
  bool _internal_has_alias() const;
  public:
  void clear_alias();
  const ::pg_query::Alias& alias() const;
  ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* alias);
  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();
  public:
  void unsafe_arena_set_allocated_alias(
      ::pg_query::Alias* alias);
  ::pg_query::Alias* unsafe_arena_release_alias();

  // bool inh = 4 [json_name = "inh"];
  void clear_inh();
  bool inh() const;
  void set_inh(bool value);
  private:
  bool _internal_inh() const;
  void _internal_set_inh(bool value);
  public:

  // int32 location = 7 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RangeVar)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr catalogname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr schemaname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr relname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr relpersistence_;
  ::pg_query::Alias* alias_;
  bool inh_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class TableFunc PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TableFunc) */ {
 public:
  inline TableFunc() : TableFunc(nullptr) {}
  virtual ~TableFunc();

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

  inline TableFunc& operator=(const TableFunc& from) {
    CopyFrom(from);
    return *this;
  }
  inline TableFunc& operator=(TableFunc&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TableFunc& default_instance();

  static inline const TableFunc* internal_default_instance() {
    return reinterpret_cast<const TableFunc*>(
               &_TableFunc_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(TableFunc& a, TableFunc& b) {
    a.Swap(&b);
  }
  inline void Swap(TableFunc* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TableFunc* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline TableFunc* New() const final {
    return CreateMaybeMessage<TableFunc>(nullptr);
  }

  TableFunc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TableFunc>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TableFunc& from);
  void MergeFrom(const TableFunc& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TableFunc* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.TableFunc";
  }
  protected:
  explicit TableFunc(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNsUrisFieldNumber = 1,
    kNsNamesFieldNumber = 2,
    kColnamesFieldNumber = 5,
    kColtypesFieldNumber = 6,
    kColtypmodsFieldNumber = 7,
    kColcollationsFieldNumber = 8,
    kColexprsFieldNumber = 9,
    kColdefexprsFieldNumber = 10,
    kDocexprFieldNumber = 3,
    kRowexprFieldNumber = 4,
    kOrdinalitycolFieldNumber = 11,
    kLocationFieldNumber = 12,
  };
  // repeated .pg_query.Node ns_uris = 1 [json_name = "ns_uris"];
  int ns_uris_size() const;
  private:
  int _internal_ns_uris_size() const;
  public:
  void clear_ns_uris();
  ::pg_query::Node* mutable_ns_uris(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_ns_uris();
  private:
  const ::pg_query::Node& _internal_ns_uris(int index) const;
  ::pg_query::Node* _internal_add_ns_uris();
  public:
  const ::pg_query::Node& ns_uris(int index) const;
  ::pg_query::Node* add_ns_uris();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      ns_uris() const;

  // repeated .pg_query.Node ns_names = 2 [json_name = "ns_names"];
  int ns_names_size() const;
  private:
  int _internal_ns_names_size() const;
  public:
  void clear_ns_names();
  ::pg_query::Node* mutable_ns_names(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_ns_names();
  private:
  const ::pg_query::Node& _internal_ns_names(int index) const;
  ::pg_query::Node* _internal_add_ns_names();
  public:
  const ::pg_query::Node& ns_names(int index) const;
  ::pg_query::Node* add_ns_names();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      ns_names() const;

  // repeated .pg_query.Node colnames = 5 [json_name = "colnames"];
  int colnames_size() const;
  private:
  int _internal_colnames_size() const;
  public:
  void clear_colnames();
  ::pg_query::Node* mutable_colnames(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_colnames();
  private:
  const ::pg_query::Node& _internal_colnames(int index) const;
  ::pg_query::Node* _internal_add_colnames();
  public:
  const ::pg_query::Node& colnames(int index) const;
  ::pg_query::Node* add_colnames();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      colnames() const;

  // repeated .pg_query.Node coltypes = 6 [json_name = "coltypes"];
  int coltypes_size() const;
  private:
  int _internal_coltypes_size() const;
  public:
  void clear_coltypes();
  ::pg_query::Node* mutable_coltypes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_coltypes();
  private:
  const ::pg_query::Node& _internal_coltypes(int index) const;
  ::pg_query::Node* _internal_add_coltypes();
  public:
  const ::pg_query::Node& coltypes(int index) const;
  ::pg_query::Node* add_coltypes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      coltypes() const;

  // repeated .pg_query.Node coltypmods = 7 [json_name = "coltypmods"];
  int coltypmods_size() const;
  private:
  int _internal_coltypmods_size() const;
  public:
  void clear_coltypmods();
  ::pg_query::Node* mutable_coltypmods(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_coltypmods();
  private:
  const ::pg_query::Node& _internal_coltypmods(int index) const;
  ::pg_query::Node* _internal_add_coltypmods();
  public:
  const ::pg_query::Node& coltypmods(int index) const;
  ::pg_query::Node* add_coltypmods();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      coltypmods() const;

  // repeated .pg_query.Node colcollations = 8 [json_name = "colcollations"];
  int colcollations_size() const;
  private:
  int _internal_colcollations_size() const;
  public:
  void clear_colcollations();
  ::pg_query::Node* mutable_colcollations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_colcollations();
  private:
  const ::pg_query::Node& _internal_colcollations(int index) const;
  ::pg_query::Node* _internal_add_colcollations();
  public:
  const ::pg_query::Node& colcollations(int index) const;
  ::pg_query::Node* add_colcollations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      colcollations() const;

  // repeated .pg_query.Node colexprs = 9 [json_name = "colexprs"];
  int colexprs_size() const;
  private:
  int _internal_colexprs_size() const;
  public:
  void clear_colexprs();
  ::pg_query::Node* mutable_colexprs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_colexprs();
  private:
  const ::pg_query::Node& _internal_colexprs(int index) const;
  ::pg_query::Node* _internal_add_colexprs();
  public:
  const ::pg_query::Node& colexprs(int index) const;
  ::pg_query::Node* add_colexprs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      colexprs() const;

  // repeated .pg_query.Node coldefexprs = 10 [json_name = "coldefexprs"];
  int coldefexprs_size() const;
  private:
  int _internal_coldefexprs_size() const;
  public:
  void clear_coldefexprs();
  ::pg_query::Node* mutable_coldefexprs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_coldefexprs();
  private:
  const ::pg_query::Node& _internal_coldefexprs(int index) const;
  ::pg_query::Node* _internal_add_coldefexprs();
  public:
  const ::pg_query::Node& coldefexprs(int index) const;
  ::pg_query::Node* add_coldefexprs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      coldefexprs() const;

  // .pg_query.Node docexpr = 3 [json_name = "docexpr"];
  bool has_docexpr() const;
  private:
  bool _internal_has_docexpr() const;
  public:
  void clear_docexpr();
  const ::pg_query::Node& docexpr() const;
  ::pg_query::Node* release_docexpr();
  ::pg_query::Node* mutable_docexpr();
  void set_allocated_docexpr(::pg_query::Node* docexpr);
  private:
  const ::pg_query::Node& _internal_docexpr() const;
  ::pg_query::Node* _internal_mutable_docexpr();
  public:
  void unsafe_arena_set_allocated_docexpr(
      ::pg_query::Node* docexpr);
  ::pg_query::Node* unsafe_arena_release_docexpr();

  // .pg_query.Node rowexpr = 4 [json_name = "rowexpr"];
  bool has_rowexpr() const;
  private:
  bool _internal_has_rowexpr() const;
  public:
  void clear_rowexpr();
  const ::pg_query::Node& rowexpr() const;
  ::pg_query::Node* release_rowexpr();
  ::pg_query::Node* mutable_rowexpr();
  void set_allocated_rowexpr(::pg_query::Node* rowexpr);
  private:
  const ::pg_query::Node& _internal_rowexpr() const;
  ::pg_query::Node* _internal_mutable_rowexpr();
  public:
  void unsafe_arena_set_allocated_rowexpr(
      ::pg_query::Node* rowexpr);
  ::pg_query::Node* unsafe_arena_release_rowexpr();

  // int32 ordinalitycol = 11 [json_name = "ordinalitycol"];
  void clear_ordinalitycol();
  ::PROTOBUF_NAMESPACE_ID::int32 ordinalitycol() const;
  void set_ordinalitycol(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_ordinalitycol() const;
  void _internal_set_ordinalitycol(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 location = 12 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.TableFunc)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ns_uris_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ns_names_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > colnames_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coltypes_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coltypmods_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > colcollations_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > colexprs_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coldefexprs_;
  ::pg_query::Node* docexpr_;
  ::pg_query::Node* rowexpr_;
  ::PROTOBUF_NAMESPACE_ID::int32 ordinalitycol_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class Expr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Expr) */ {
 public:
  inline Expr() : Expr(nullptr) {}
  virtual ~Expr();

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

  inline Expr& operator=(const Expr& from) {
    CopyFrom(from);
    return *this;
  }
  inline Expr& operator=(Expr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Expr& default_instance();

  static inline const Expr* internal_default_instance() {
    return reinterpret_cast<const Expr*>(
               &_Expr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(Expr& a, Expr& b) {
    a.Swap(&b);
  }
  inline void Swap(Expr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Expr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Expr* New() const final {
    return CreateMaybeMessage<Expr>(nullptr);
  }

  Expr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Expr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Expr& from);
  void MergeFrom(const Expr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Expr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.Expr";
  }
  protected:
  explicit Expr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // @@protoc_insertion_point(class_scope:pg_query.Expr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class Var PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Var) */ {
 public:
  inline Var() : Var(nullptr) {}
  virtual ~Var();

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

  inline Var& operator=(const Var& from) {
    CopyFrom(from);
    return *this;
  }
  inline Var& operator=(Var&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Var& default_instance();

  static inline const Var* internal_default_instance() {
    return reinterpret_cast<const Var*>(
               &_Var_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(Var& a, Var& b) {
    a.Swap(&b);
  }
  inline void Swap(Var* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Var* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Var* New() const final {
    return CreateMaybeMessage<Var>(nullptr);
  }

  Var* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Var>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Var& from);
  void MergeFrom(const Var& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Var* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.Var";
  }
  protected:
  explicit Var(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kVarnoFieldNumber = 2,
    kVarattnoFieldNumber = 3,
    kVartypeFieldNumber = 4,
    kVartypmodFieldNumber = 5,
    kVarcollidFieldNumber = 6,
    kVarlevelsupFieldNumber = 7,
    kVarnosynFieldNumber = 8,
    kVarattnosynFieldNumber = 9,
    kLocationFieldNumber = 10,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 varno = 2 [json_name = "varno"];
  void clear_varno();
  ::PROTOBUF_NAMESPACE_ID::uint32 varno() const;
  void set_varno(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_varno() const;
  void _internal_set_varno(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 varattno = 3 [json_name = "varattno"];
  void clear_varattno();
  ::PROTOBUF_NAMESPACE_ID::int32 varattno() const;
  void set_varattno(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_varattno() const;
  void _internal_set_varattno(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 vartype = 4 [json_name = "vartype"];
  void clear_vartype();
  ::PROTOBUF_NAMESPACE_ID::uint32 vartype() const;
  void set_vartype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_vartype() const;
  void _internal_set_vartype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 vartypmod = 5 [json_name = "vartypmod"];
  void clear_vartypmod();
  ::PROTOBUF_NAMESPACE_ID::int32 vartypmod() const;
  void set_vartypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_vartypmod() const;
  void _internal_set_vartypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 varcollid = 6 [json_name = "varcollid"];
  void clear_varcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 varcollid() const;
  void set_varcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_varcollid() const;
  void _internal_set_varcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 varlevelsup = 7 [json_name = "varlevelsup"];
  void clear_varlevelsup();
  ::PROTOBUF_NAMESPACE_ID::uint32 varlevelsup() const;
  void set_varlevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_varlevelsup() const;
  void _internal_set_varlevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 varnosyn = 8 [json_name = "varnosyn"];
  void clear_varnosyn();
  ::PROTOBUF_NAMESPACE_ID::uint32 varnosyn() const;
  void set_varnosyn(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_varnosyn() const;
  void _internal_set_varnosyn(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 varattnosyn = 9 [json_name = "varattnosyn"];
  void clear_varattnosyn();
  ::PROTOBUF_NAMESPACE_ID::int32 varattnosyn() const;
  void set_varattnosyn(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_varattnosyn() const;
  void _internal_set_varattnosyn(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 location = 10 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.Var)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 varno_;
  ::PROTOBUF_NAMESPACE_ID::int32 varattno_;
  ::PROTOBUF_NAMESPACE_ID::uint32 vartype_;
  ::PROTOBUF_NAMESPACE_ID::int32 vartypmod_;
  ::PROTOBUF_NAMESPACE_ID::uint32 varcollid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 varlevelsup_;
  ::PROTOBUF_NAMESPACE_ID::uint32 varnosyn_;
  ::PROTOBUF_NAMESPACE_ID::int32 varattnosyn_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class Param PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Param) */ {
 public:
  inline Param() : Param(nullptr) {}
  virtual ~Param();

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

  inline Param& operator=(const Param& from) {
    CopyFrom(from);
    return *this;
  }
  inline Param& operator=(Param&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Param& default_instance();

  static inline const Param* internal_default_instance() {
    return reinterpret_cast<const Param*>(
               &_Param_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(Param& a, Param& b) {
    a.Swap(&b);
  }
  inline void Swap(Param* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Param* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Param* New() const final {
    return CreateMaybeMessage<Param>(nullptr);
  }

  Param* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Param>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Param& from);
  void MergeFrom(const Param& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Param* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.Param";
  }
  protected:
  explicit Param(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kParamkindFieldNumber = 2,
    kParamidFieldNumber = 3,
    kParamtypeFieldNumber = 4,
    kParamtypmodFieldNumber = 5,
    kParamcollidFieldNumber = 6,
    kLocationFieldNumber = 7,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.ParamKind paramkind = 2 [json_name = "paramkind"];
  void clear_paramkind();
  ::pg_query::ParamKind paramkind() const;
  void set_paramkind(::pg_query::ParamKind value);
  private:
  ::pg_query::ParamKind _internal_paramkind() const;
  void _internal_set_paramkind(::pg_query::ParamKind value);
  public:

  // int32 paramid = 3 [json_name = "paramid"];
  void clear_paramid();
  ::PROTOBUF_NAMESPACE_ID::int32 paramid() const;
  void set_paramid(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_paramid() const;
  void _internal_set_paramid(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 paramtype = 4 [json_name = "paramtype"];
  void clear_paramtype();
  ::PROTOBUF_NAMESPACE_ID::uint32 paramtype() const;
  void set_paramtype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_paramtype() const;
  void _internal_set_paramtype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 paramtypmod = 5 [json_name = "paramtypmod"];
  void clear_paramtypmod();
  ::PROTOBUF_NAMESPACE_ID::int32 paramtypmod() const;
  void set_paramtypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_paramtypmod() const;
  void _internal_set_paramtypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 paramcollid = 6 [json_name = "paramcollid"];
  void clear_paramcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 paramcollid() const;
  void set_paramcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_paramcollid() const;
  void _internal_set_paramcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 location = 7 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.Param)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  int paramkind_;
  ::PROTOBUF_NAMESPACE_ID::int32 paramid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 paramtype_;
  ::PROTOBUF_NAMESPACE_ID::int32 paramtypmod_;
  ::PROTOBUF_NAMESPACE_ID::uint32 paramcollid_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class Aggref PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Aggref) */ {
 public:
  inline Aggref() : Aggref(nullptr) {}
  virtual ~Aggref();

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

  inline Aggref& operator=(const Aggref& from) {
    CopyFrom(from);
    return *this;
  }
  inline Aggref& operator=(Aggref&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Aggref& default_instance();

  static inline const Aggref* internal_default_instance() {
    return reinterpret_cast<const Aggref*>(
               &_Aggref_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(Aggref& a, Aggref& b) {
    a.Swap(&b);
  }
  inline void Swap(Aggref* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Aggref* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Aggref* New() const final {
    return CreateMaybeMessage<Aggref>(nullptr);
  }

  Aggref* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Aggref>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Aggref& from);
  void MergeFrom(const Aggref& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Aggref* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.Aggref";
  }
  protected:
  explicit Aggref(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAggargtypesFieldNumber = 7,
    kAggdirectargsFieldNumber = 8,
    kArgsFieldNumber = 9,
    kAggorderFieldNumber = 10,
    kAggdistinctFieldNumber = 11,
    kAggkindFieldNumber = 15,
    kXprFieldNumber = 1,
    kAggfilterFieldNumber = 12,
    kAggfnoidFieldNumber = 2,
    kAggtypeFieldNumber = 3,
    kAggcollidFieldNumber = 4,
    kInputcollidFieldNumber = 5,
    kAggtranstypeFieldNumber = 6,
    kAggstarFieldNumber = 13,
    kAggvariadicFieldNumber = 14,
    kAgglevelsupFieldNumber = 16,
    kAggsplitFieldNumber = 17,
    kLocationFieldNumber = 18,
  };
  // repeated .pg_query.Node aggargtypes = 7 [json_name = "aggargtypes"];
  int aggargtypes_size() const;
  private:
  int _internal_aggargtypes_size() const;
  public:
  void clear_aggargtypes();
  ::pg_query::Node* mutable_aggargtypes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_aggargtypes();
  private:
  const ::pg_query::Node& _internal_aggargtypes(int index) const;
  ::pg_query::Node* _internal_add_aggargtypes();
  public:
  const ::pg_query::Node& aggargtypes(int index) const;
  ::pg_query::Node* add_aggargtypes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      aggargtypes() const;

  // repeated .pg_query.Node aggdirectargs = 8 [json_name = "aggdirectargs"];
  int aggdirectargs_size() const;
  private:
  int _internal_aggdirectargs_size() const;
  public:
  void clear_aggdirectargs();
  ::pg_query::Node* mutable_aggdirectargs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_aggdirectargs();
  private:
  const ::pg_query::Node& _internal_aggdirectargs(int index) const;
  ::pg_query::Node* _internal_add_aggdirectargs();
  public:
  const ::pg_query::Node& aggdirectargs(int index) const;
  ::pg_query::Node* add_aggdirectargs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      aggdirectargs() const;

  // repeated .pg_query.Node args = 9 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // repeated .pg_query.Node aggorder = 10 [json_name = "aggorder"];
  int aggorder_size() const;
  private:
  int _internal_aggorder_size() const;
  public:
  void clear_aggorder();
  ::pg_query::Node* mutable_aggorder(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_aggorder();
  private:
  const ::pg_query::Node& _internal_aggorder(int index) const;
  ::pg_query::Node* _internal_add_aggorder();
  public:
  const ::pg_query::Node& aggorder(int index) const;
  ::pg_query::Node* add_aggorder();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      aggorder() const;

  // repeated .pg_query.Node aggdistinct = 11 [json_name = "aggdistinct"];
  int aggdistinct_size() const;
  private:
  int _internal_aggdistinct_size() const;
  public:
  void clear_aggdistinct();
  ::pg_query::Node* mutable_aggdistinct(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_aggdistinct();
  private:
  const ::pg_query::Node& _internal_aggdistinct(int index) const;
  ::pg_query::Node* _internal_add_aggdistinct();
  public:
  const ::pg_query::Node& aggdistinct(int index) const;
  ::pg_query::Node* add_aggdistinct();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      aggdistinct() const;

  // string aggkind = 15 [json_name = "aggkind"];
  void clear_aggkind();
  const std::string& aggkind() const;
  void set_aggkind(const std::string& value);
  void set_aggkind(std::string&& value);
  void set_aggkind(const char* value);
  void set_aggkind(const char* value, size_t size);
  std::string* mutable_aggkind();
  std::string* release_aggkind();
  void set_allocated_aggkind(std::string* aggkind);
  private:
  const std::string& _internal_aggkind() const;
  void _internal_set_aggkind(const std::string& value);
  std::string* _internal_mutable_aggkind();
  public:

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node aggfilter = 12 [json_name = "aggfilter"];
  bool has_aggfilter() const;
  private:
  bool _internal_has_aggfilter() const;
  public:
  void clear_aggfilter();
  const ::pg_query::Node& aggfilter() const;
  ::pg_query::Node* release_aggfilter();
  ::pg_query::Node* mutable_aggfilter();
  void set_allocated_aggfilter(::pg_query::Node* aggfilter);
  private:
  const ::pg_query::Node& _internal_aggfilter() const;
  ::pg_query::Node* _internal_mutable_aggfilter();
  public:
  void unsafe_arena_set_allocated_aggfilter(
      ::pg_query::Node* aggfilter);
  ::pg_query::Node* unsafe_arena_release_aggfilter();

  // uint32 aggfnoid = 2 [json_name = "aggfnoid"];
  void clear_aggfnoid();
  ::PROTOBUF_NAMESPACE_ID::uint32 aggfnoid() const;
  void set_aggfnoid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_aggfnoid() const;
  void _internal_set_aggfnoid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 aggtype = 3 [json_name = "aggtype"];
  void clear_aggtype();
  ::PROTOBUF_NAMESPACE_ID::uint32 aggtype() const;
  void set_aggtype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_aggtype() const;
  void _internal_set_aggtype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 aggcollid = 4 [json_name = "aggcollid"];
  void clear_aggcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 aggcollid() const;
  void set_aggcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_aggcollid() const;
  void _internal_set_aggcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 inputcollid = 5 [json_name = "inputcollid"];
  void clear_inputcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid() const;
  void set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_inputcollid() const;
  void _internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 aggtranstype = 6 [json_name = "aggtranstype"];
  void clear_aggtranstype();
  ::PROTOBUF_NAMESPACE_ID::uint32 aggtranstype() const;
  void set_aggtranstype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_aggtranstype() const;
  void _internal_set_aggtranstype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool aggstar = 13 [json_name = "aggstar"];
  void clear_aggstar();
  bool aggstar() const;
  void set_aggstar(bool value);
  private:
  bool _internal_aggstar() const;
  void _internal_set_aggstar(bool value);
  public:

  // bool aggvariadic = 14 [json_name = "aggvariadic"];
  void clear_aggvariadic();
  bool aggvariadic() const;
  void set_aggvariadic(bool value);
  private:
  bool _internal_aggvariadic() const;
  void _internal_set_aggvariadic(bool value);
  public:

  // uint32 agglevelsup = 16 [json_name = "agglevelsup"];
  void clear_agglevelsup();
  ::PROTOBUF_NAMESPACE_ID::uint32 agglevelsup() const;
  void set_agglevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_agglevelsup() const;
  void _internal_set_agglevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .pg_query.AggSplit aggsplit = 17 [json_name = "aggsplit"];
  void clear_aggsplit();
  ::pg_query::AggSplit aggsplit() const;
  void set_aggsplit(::pg_query::AggSplit value);
  private:
  ::pg_query::AggSplit _internal_aggsplit() const;
  void _internal_set_aggsplit(::pg_query::AggSplit value);
  public:

  // int32 location = 18 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.Aggref)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > aggargtypes_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > aggdirectargs_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > aggorder_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > aggdistinct_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aggkind_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* aggfilter_;
  ::PROTOBUF_NAMESPACE_ID::uint32 aggfnoid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 aggtype_;
  ::PROTOBUF_NAMESPACE_ID::uint32 aggcollid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 aggtranstype_;
  bool aggstar_;
  bool aggvariadic_;
  ::PROTOBUF_NAMESPACE_ID::uint32 agglevelsup_;
  int aggsplit_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class GroupingFunc PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.GroupingFunc) */ {
 public:
  inline GroupingFunc() : GroupingFunc(nullptr) {}
  virtual ~GroupingFunc();

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

  inline GroupingFunc& operator=(const GroupingFunc& from) {
    CopyFrom(from);
    return *this;
  }
  inline GroupingFunc& operator=(GroupingFunc&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GroupingFunc& default_instance();

  static inline const GroupingFunc* internal_default_instance() {
    return reinterpret_cast<const GroupingFunc*>(
               &_GroupingFunc_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(GroupingFunc& a, GroupingFunc& b) {
    a.Swap(&b);
  }
  inline void Swap(GroupingFunc* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GroupingFunc* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline GroupingFunc* New() const final {
    return CreateMaybeMessage<GroupingFunc>(nullptr);
  }

  GroupingFunc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GroupingFunc>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GroupingFunc& from);
  void MergeFrom(const GroupingFunc& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GroupingFunc* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.GroupingFunc";
  }
  protected:
  explicit GroupingFunc(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 2,
    kRefsFieldNumber = 3,
    kColsFieldNumber = 4,
    kXprFieldNumber = 1,
    kAgglevelsupFieldNumber = 5,
    kLocationFieldNumber = 6,
  };
  // repeated .pg_query.Node args = 2 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // repeated .pg_query.Node refs = 3 [json_name = "refs"];
  int refs_size() const;
  private:
  int _internal_refs_size() const;
  public:
  void clear_refs();
  ::pg_query::Node* mutable_refs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_refs();
  private:
  const ::pg_query::Node& _internal_refs(int index) const;
  ::pg_query::Node* _internal_add_refs();
  public:
  const ::pg_query::Node& refs(int index) const;
  ::pg_query::Node* add_refs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      refs() const;

  // repeated .pg_query.Node cols = 4 [json_name = "cols"];
  int cols_size() const;
  private:
  int _internal_cols_size() const;
  public:
  void clear_cols();
  ::pg_query::Node* mutable_cols(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_cols();
  private:
  const ::pg_query::Node& _internal_cols(int index) const;
  ::pg_query::Node* _internal_add_cols();
  public:
  const ::pg_query::Node& cols(int index) const;
  ::pg_query::Node* add_cols();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      cols() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 agglevelsup = 5 [json_name = "agglevelsup"];
  void clear_agglevelsup();
  ::PROTOBUF_NAMESPACE_ID::uint32 agglevelsup() const;
  void set_agglevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_agglevelsup() const;
  void _internal_set_agglevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 location = 6 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.GroupingFunc)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > refs_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > cols_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 agglevelsup_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class WindowFunc PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.WindowFunc) */ {
 public:
  inline WindowFunc() : WindowFunc(nullptr) {}
  virtual ~WindowFunc();

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

  inline WindowFunc& operator=(const WindowFunc& from) {
    CopyFrom(from);
    return *this;
  }
  inline WindowFunc& operator=(WindowFunc&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const WindowFunc& default_instance();

  static inline const WindowFunc* internal_default_instance() {
    return reinterpret_cast<const WindowFunc*>(
               &_WindowFunc_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(WindowFunc& a, WindowFunc& b) {
    a.Swap(&b);
  }
  inline void Swap(WindowFunc* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(WindowFunc* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline WindowFunc* New() const final {
    return CreateMaybeMessage<WindowFunc>(nullptr);
  }

  WindowFunc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WindowFunc>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WindowFunc& from);
  void MergeFrom(const WindowFunc& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WindowFunc* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.WindowFunc";
  }
  protected:
  explicit WindowFunc(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 6,
    kXprFieldNumber = 1,
    kAggfilterFieldNumber = 7,
    kWinfnoidFieldNumber = 2,
    kWintypeFieldNumber = 3,
    kWincollidFieldNumber = 4,
    kInputcollidFieldNumber = 5,
    kWinrefFieldNumber = 8,
    kWinstarFieldNumber = 9,
    kWinaggFieldNumber = 10,
    kLocationFieldNumber = 11,
  };
  // repeated .pg_query.Node args = 6 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node aggfilter = 7 [json_name = "aggfilter"];
  bool has_aggfilter() const;
  private:
  bool _internal_has_aggfilter() const;
  public:
  void clear_aggfilter();
  const ::pg_query::Node& aggfilter() const;
  ::pg_query::Node* release_aggfilter();
  ::pg_query::Node* mutable_aggfilter();
  void set_allocated_aggfilter(::pg_query::Node* aggfilter);
  private:
  const ::pg_query::Node& _internal_aggfilter() const;
  ::pg_query::Node* _internal_mutable_aggfilter();
  public:
  void unsafe_arena_set_allocated_aggfilter(
      ::pg_query::Node* aggfilter);
  ::pg_query::Node* unsafe_arena_release_aggfilter();

  // uint32 winfnoid = 2 [json_name = "winfnoid"];
  void clear_winfnoid();
  ::PROTOBUF_NAMESPACE_ID::uint32 winfnoid() const;
  void set_winfnoid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_winfnoid() const;
  void _internal_set_winfnoid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 wintype = 3 [json_name = "wintype"];
  void clear_wintype();
  ::PROTOBUF_NAMESPACE_ID::uint32 wintype() const;
  void set_wintype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_wintype() const;
  void _internal_set_wintype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 wincollid = 4 [json_name = "wincollid"];
  void clear_wincollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 wincollid() const;
  void set_wincollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_wincollid() const;
  void _internal_set_wincollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 inputcollid = 5 [json_name = "inputcollid"];
  void clear_inputcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid() const;
  void set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_inputcollid() const;
  void _internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 winref = 8 [json_name = "winref"];
  void clear_winref();
  ::PROTOBUF_NAMESPACE_ID::uint32 winref() const;
  void set_winref(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_winref() const;
  void _internal_set_winref(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool winstar = 9 [json_name = "winstar"];
  void clear_winstar();
  bool winstar() const;
  void set_winstar(bool value);
  private:
  bool _internal_winstar() const;
  void _internal_set_winstar(bool value);
  public:

  // bool winagg = 10 [json_name = "winagg"];
  void clear_winagg();
  bool winagg() const;
  void set_winagg(bool value);
  private:
  bool _internal_winagg() const;
  void _internal_set_winagg(bool value);
  public:

  // int32 location = 11 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.WindowFunc)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* aggfilter_;
  ::PROTOBUF_NAMESPACE_ID::uint32 winfnoid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 wintype_;
  ::PROTOBUF_NAMESPACE_ID::uint32 wincollid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 winref_;
  bool winstar_;
  bool winagg_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class SubscriptingRef PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SubscriptingRef) */ {
 public:
  inline SubscriptingRef() : SubscriptingRef(nullptr) {}
  virtual ~SubscriptingRef();

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

  inline SubscriptingRef& operator=(const SubscriptingRef& from) {
    CopyFrom(from);
    return *this;
  }
  inline SubscriptingRef& operator=(SubscriptingRef&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SubscriptingRef& default_instance();

  static inline const SubscriptingRef* internal_default_instance() {
    return reinterpret_cast<const SubscriptingRef*>(
               &_SubscriptingRef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(SubscriptingRef& a, SubscriptingRef& b) {
    a.Swap(&b);
  }
  inline void Swap(SubscriptingRef* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SubscriptingRef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SubscriptingRef* New() const final {
    return CreateMaybeMessage<SubscriptingRef>(nullptr);
  }

  SubscriptingRef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SubscriptingRef>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SubscriptingRef& from);
  void MergeFrom(const SubscriptingRef& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SubscriptingRef* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.SubscriptingRef";
  }
  protected:
  explicit SubscriptingRef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRefupperindexprFieldNumber = 6,
    kReflowerindexprFieldNumber = 7,
    kXprFieldNumber = 1,
    kRefexprFieldNumber = 8,
    kRefassgnexprFieldNumber = 9,
    kRefcontainertypeFieldNumber = 2,
    kRefelemtypeFieldNumber = 3,
    kReftypmodFieldNumber = 4,
    kRefcollidFieldNumber = 5,
  };
  // repeated .pg_query.Node refupperindexpr = 6 [json_name = "refupperindexpr"];
  int refupperindexpr_size() const;
  private:
  int _internal_refupperindexpr_size() const;
  public:
  void clear_refupperindexpr();
  ::pg_query::Node* mutable_refupperindexpr(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_refupperindexpr();
  private:
  const ::pg_query::Node& _internal_refupperindexpr(int index) const;
  ::pg_query::Node* _internal_add_refupperindexpr();
  public:
  const ::pg_query::Node& refupperindexpr(int index) const;
  ::pg_query::Node* add_refupperindexpr();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      refupperindexpr() const;

  // repeated .pg_query.Node reflowerindexpr = 7 [json_name = "reflowerindexpr"];
  int reflowerindexpr_size() const;
  private:
  int _internal_reflowerindexpr_size() const;
  public:
  void clear_reflowerindexpr();
  ::pg_query::Node* mutable_reflowerindexpr(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_reflowerindexpr();
  private:
  const ::pg_query::Node& _internal_reflowerindexpr(int index) const;
  ::pg_query::Node* _internal_add_reflowerindexpr();
  public:
  const ::pg_query::Node& reflowerindexpr(int index) const;
  ::pg_query::Node* add_reflowerindexpr();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      reflowerindexpr() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node refexpr = 8 [json_name = "refexpr"];
  bool has_refexpr() const;
  private:
  bool _internal_has_refexpr() const;
  public:
  void clear_refexpr();
  const ::pg_query::Node& refexpr() const;
  ::pg_query::Node* release_refexpr();
  ::pg_query::Node* mutable_refexpr();
  void set_allocated_refexpr(::pg_query::Node* refexpr);
  private:
  const ::pg_query::Node& _internal_refexpr() const;
  ::pg_query::Node* _internal_mutable_refexpr();
  public:
  void unsafe_arena_set_allocated_refexpr(
      ::pg_query::Node* refexpr);
  ::pg_query::Node* unsafe_arena_release_refexpr();

  // .pg_query.Node refassgnexpr = 9 [json_name = "refassgnexpr"];
  bool has_refassgnexpr() const;
  private:
  bool _internal_has_refassgnexpr() const;
  public:
  void clear_refassgnexpr();
  const ::pg_query::Node& refassgnexpr() const;
  ::pg_query::Node* release_refassgnexpr();
  ::pg_query::Node* mutable_refassgnexpr();
  void set_allocated_refassgnexpr(::pg_query::Node* refassgnexpr);
  private:
  const ::pg_query::Node& _internal_refassgnexpr() const;
  ::pg_query::Node* _internal_mutable_refassgnexpr();
  public:
  void unsafe_arena_set_allocated_refassgnexpr(
      ::pg_query::Node* refassgnexpr);
  ::pg_query::Node* unsafe_arena_release_refassgnexpr();

  // uint32 refcontainertype = 2 [json_name = "refcontainertype"];
  void clear_refcontainertype();
  ::PROTOBUF_NAMESPACE_ID::uint32 refcontainertype() const;
  void set_refcontainertype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_refcontainertype() const;
  void _internal_set_refcontainertype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 refelemtype = 3 [json_name = "refelemtype"];
  void clear_refelemtype();
  ::PROTOBUF_NAMESPACE_ID::uint32 refelemtype() const;
  void set_refelemtype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_refelemtype() const;
  void _internal_set_refelemtype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 reftypmod = 4 [json_name = "reftypmod"];
  void clear_reftypmod();
  ::PROTOBUF_NAMESPACE_ID::int32 reftypmod() const;
  void set_reftypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_reftypmod() const;
  void _internal_set_reftypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 refcollid = 5 [json_name = "refcollid"];
  void clear_refcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 refcollid() const;
  void set_refcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_refcollid() const;
  void _internal_set_refcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.SubscriptingRef)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > refupperindexpr_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > reflowerindexpr_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* refexpr_;
  ::pg_query::Node* refassgnexpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 refcontainertype_;
  ::PROTOBUF_NAMESPACE_ID::uint32 refelemtype_;
  ::PROTOBUF_NAMESPACE_ID::int32 reftypmod_;
  ::PROTOBUF_NAMESPACE_ID::uint32 refcollid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class FuncExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FuncExpr) */ {
 public:
  inline FuncExpr() : FuncExpr(nullptr) {}
  virtual ~FuncExpr();

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

  inline FuncExpr& operator=(const FuncExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline FuncExpr& operator=(FuncExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const FuncExpr& default_instance();

  static inline const FuncExpr* internal_default_instance() {
    return reinterpret_cast<const FuncExpr*>(
               &_FuncExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(FuncExpr& a, FuncExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(FuncExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FuncExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline FuncExpr* New() const final {
    return CreateMaybeMessage<FuncExpr>(nullptr);
  }

  FuncExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FuncExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const FuncExpr& from);
  void MergeFrom(const FuncExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FuncExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.FuncExpr";
  }
  protected:
  explicit FuncExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 9,
    kXprFieldNumber = 1,
    kFuncidFieldNumber = 2,
    kFuncresulttypeFieldNumber = 3,
    kFuncretsetFieldNumber = 4,
    kFuncvariadicFieldNumber = 5,
    kFuncformatFieldNumber = 6,
    kFunccollidFieldNumber = 7,
    kInputcollidFieldNumber = 8,
    kLocationFieldNumber = 10,
  };
  // repeated .pg_query.Node args = 9 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 funcid = 2 [json_name = "funcid"];
  void clear_funcid();
  ::PROTOBUF_NAMESPACE_ID::uint32 funcid() const;
  void set_funcid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_funcid() const;
  void _internal_set_funcid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 funcresulttype = 3 [json_name = "funcresulttype"];
  void clear_funcresulttype();
  ::PROTOBUF_NAMESPACE_ID::uint32 funcresulttype() const;
  void set_funcresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_funcresulttype() const;
  void _internal_set_funcresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool funcretset = 4 [json_name = "funcretset"];
  void clear_funcretset();
  bool funcretset() const;
  void set_funcretset(bool value);
  private:
  bool _internal_funcretset() const;
  void _internal_set_funcretset(bool value);
  public:

  // bool funcvariadic = 5 [json_name = "funcvariadic"];
  void clear_funcvariadic();
  bool funcvariadic() const;
  void set_funcvariadic(bool value);
  private:
  bool _internal_funcvariadic() const;
  void _internal_set_funcvariadic(bool value);
  public:

  // .pg_query.CoercionForm funcformat = 6 [json_name = "funcformat"];
  void clear_funcformat();
  ::pg_query::CoercionForm funcformat() const;
  void set_funcformat(::pg_query::CoercionForm value);
  private:
  ::pg_query::CoercionForm _internal_funcformat() const;
  void _internal_set_funcformat(::pg_query::CoercionForm value);
  public:

  // uint32 funccollid = 7 [json_name = "funccollid"];
  void clear_funccollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 funccollid() const;
  void set_funccollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_funccollid() const;
  void _internal_set_funccollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 inputcollid = 8 [json_name = "inputcollid"];
  void clear_inputcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid() const;
  void set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_inputcollid() const;
  void _internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 location = 10 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.FuncExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 funcid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 funcresulttype_;
  bool funcretset_;
  bool funcvariadic_;
  int funcformat_;
  ::PROTOBUF_NAMESPACE_ID::uint32 funccollid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class NamedArgExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.NamedArgExpr) */ {
 public:
  inline NamedArgExpr() : NamedArgExpr(nullptr) {}
  virtual ~NamedArgExpr();

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

  inline NamedArgExpr& operator=(const NamedArgExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline NamedArgExpr& operator=(NamedArgExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const NamedArgExpr& default_instance();

  static inline const NamedArgExpr* internal_default_instance() {
    return reinterpret_cast<const NamedArgExpr*>(
               &_NamedArgExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(NamedArgExpr& a, NamedArgExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(NamedArgExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NamedArgExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline NamedArgExpr* New() const final {
    return CreateMaybeMessage<NamedArgExpr>(nullptr);
  }

  NamedArgExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<NamedArgExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const NamedArgExpr& from);
  void MergeFrom(const NamedArgExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NamedArgExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.NamedArgExpr";
  }
  protected:
  explicit NamedArgExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNameFieldNumber = 3,
    kXprFieldNumber = 1,
    kArgFieldNumber = 2,
    kArgnumberFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // string name = 3 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // int32 argnumber = 4 [json_name = "argnumber"];
  void clear_argnumber();
  ::PROTOBUF_NAMESPACE_ID::int32 argnumber() const;
  void set_argnumber(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_argnumber() const;
  void _internal_set_argnumber(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.NamedArgExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* arg_;
  ::PROTOBUF_NAMESPACE_ID::int32 argnumber_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class OpExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.OpExpr) */ {
 public:
  inline OpExpr() : OpExpr(nullptr) {}
  virtual ~OpExpr();

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

  inline OpExpr& operator=(const OpExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline OpExpr& operator=(OpExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const OpExpr& default_instance();

  static inline const OpExpr* internal_default_instance() {
    return reinterpret_cast<const OpExpr*>(
               &_OpExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  friend void swap(OpExpr& a, OpExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(OpExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OpExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline OpExpr* New() const final {
    return CreateMaybeMessage<OpExpr>(nullptr);
  }

  OpExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<OpExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const OpExpr& from);
  void MergeFrom(const OpExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OpExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.OpExpr";
  }
  protected:
  explicit OpExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 8,
    kXprFieldNumber = 1,
    kOpnoFieldNumber = 2,
    kOpfuncidFieldNumber = 3,
    kOpresulttypeFieldNumber = 4,
    kOpretsetFieldNumber = 5,
    kOpcollidFieldNumber = 6,
    kInputcollidFieldNumber = 7,
    kLocationFieldNumber = 9,
  };
  // repeated .pg_query.Node args = 8 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 opno = 2 [json_name = "opno"];
  void clear_opno();
  ::PROTOBUF_NAMESPACE_ID::uint32 opno() const;
  void set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opno() const;
  void _internal_set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 opfuncid = 3 [json_name = "opfuncid"];
  void clear_opfuncid();
  ::PROTOBUF_NAMESPACE_ID::uint32 opfuncid() const;
  void set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opfuncid() const;
  void _internal_set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 opresulttype = 4 [json_name = "opresulttype"];
  void clear_opresulttype();
  ::PROTOBUF_NAMESPACE_ID::uint32 opresulttype() const;
  void set_opresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opresulttype() const;
  void _internal_set_opresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool opretset = 5 [json_name = "opretset"];
  void clear_opretset();
  bool opretset() const;
  void set_opretset(bool value);
  private:
  bool _internal_opretset() const;
  void _internal_set_opretset(bool value);
  public:

  // uint32 opcollid = 6 [json_name = "opcollid"];
  void clear_opcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 opcollid() const;
  void set_opcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opcollid() const;
  void _internal_set_opcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 inputcollid = 7 [json_name = "inputcollid"];
  void clear_inputcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid() const;
  void set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_inputcollid() const;
  void _internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 location = 9 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.OpExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opno_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opfuncid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opresulttype_;
  bool opretset_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opcollid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class DistinctExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DistinctExpr) */ {
 public:
  inline DistinctExpr() : DistinctExpr(nullptr) {}
  virtual ~DistinctExpr();

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

  inline DistinctExpr& operator=(const DistinctExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline DistinctExpr& operator=(DistinctExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DistinctExpr& default_instance();

  static inline const DistinctExpr* internal_default_instance() {
    return reinterpret_cast<const DistinctExpr*>(
               &_DistinctExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

  friend void swap(DistinctExpr& a, DistinctExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(DistinctExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DistinctExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline DistinctExpr* New() const final {
    return CreateMaybeMessage<DistinctExpr>(nullptr);
  }

  DistinctExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DistinctExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DistinctExpr& from);
  void MergeFrom(const DistinctExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DistinctExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DistinctExpr";
  }
  protected:
  explicit DistinctExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 8,
    kXprFieldNumber = 1,
    kOpnoFieldNumber = 2,
    kOpfuncidFieldNumber = 3,
    kOpresulttypeFieldNumber = 4,
    kOpretsetFieldNumber = 5,
    kOpcollidFieldNumber = 6,
    kInputcollidFieldNumber = 7,
    kLocationFieldNumber = 9,
  };
  // repeated .pg_query.Node args = 8 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 opno = 2 [json_name = "opno"];
  void clear_opno();
  ::PROTOBUF_NAMESPACE_ID::uint32 opno() const;
  void set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opno() const;
  void _internal_set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 opfuncid = 3 [json_name = "opfuncid"];
  void clear_opfuncid();
  ::PROTOBUF_NAMESPACE_ID::uint32 opfuncid() const;
  void set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opfuncid() const;
  void _internal_set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 opresulttype = 4 [json_name = "opresulttype"];
  void clear_opresulttype();
  ::PROTOBUF_NAMESPACE_ID::uint32 opresulttype() const;
  void set_opresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opresulttype() const;
  void _internal_set_opresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool opretset = 5 [json_name = "opretset"];
  void clear_opretset();
  bool opretset() const;
  void set_opretset(bool value);
  private:
  bool _internal_opretset() const;
  void _internal_set_opretset(bool value);
  public:

  // uint32 opcollid = 6 [json_name = "opcollid"];
  void clear_opcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 opcollid() const;
  void set_opcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opcollid() const;
  void _internal_set_opcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 inputcollid = 7 [json_name = "inputcollid"];
  void clear_inputcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid() const;
  void set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_inputcollid() const;
  void _internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 location = 9 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.DistinctExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opno_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opfuncid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opresulttype_;
  bool opretset_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opcollid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class NullIfExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.NullIfExpr) */ {
 public:
  inline NullIfExpr() : NullIfExpr(nullptr) {}
  virtual ~NullIfExpr();

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

  inline NullIfExpr& operator=(const NullIfExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline NullIfExpr& operator=(NullIfExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const NullIfExpr& default_instance();

  static inline const NullIfExpr* internal_default_instance() {
    return reinterpret_cast<const NullIfExpr*>(
               &_NullIfExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  friend void swap(NullIfExpr& a, NullIfExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(NullIfExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NullIfExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline NullIfExpr* New() const final {
    return CreateMaybeMessage<NullIfExpr>(nullptr);
  }

  NullIfExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<NullIfExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const NullIfExpr& from);
  void MergeFrom(const NullIfExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NullIfExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.NullIfExpr";
  }
  protected:
  explicit NullIfExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 8,
    kXprFieldNumber = 1,
    kOpnoFieldNumber = 2,
    kOpfuncidFieldNumber = 3,
    kOpresulttypeFieldNumber = 4,
    kOpretsetFieldNumber = 5,
    kOpcollidFieldNumber = 6,
    kInputcollidFieldNumber = 7,
    kLocationFieldNumber = 9,
  };
  // repeated .pg_query.Node args = 8 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 opno = 2 [json_name = "opno"];
  void clear_opno();
  ::PROTOBUF_NAMESPACE_ID::uint32 opno() const;
  void set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opno() const;
  void _internal_set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 opfuncid = 3 [json_name = "opfuncid"];
  void clear_opfuncid();
  ::PROTOBUF_NAMESPACE_ID::uint32 opfuncid() const;
  void set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opfuncid() const;
  void _internal_set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 opresulttype = 4 [json_name = "opresulttype"];
  void clear_opresulttype();
  ::PROTOBUF_NAMESPACE_ID::uint32 opresulttype() const;
  void set_opresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opresulttype() const;
  void _internal_set_opresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool opretset = 5 [json_name = "opretset"];
  void clear_opretset();
  bool opretset() const;
  void set_opretset(bool value);
  private:
  bool _internal_opretset() const;
  void _internal_set_opretset(bool value);
  public:

  // uint32 opcollid = 6 [json_name = "opcollid"];
  void clear_opcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 opcollid() const;
  void set_opcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opcollid() const;
  void _internal_set_opcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 inputcollid = 7 [json_name = "inputcollid"];
  void clear_inputcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid() const;
  void set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_inputcollid() const;
  void _internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 location = 9 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.NullIfExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opno_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opfuncid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opresulttype_;
  bool opretset_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opcollid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ScalarArrayOpExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ScalarArrayOpExpr) */ {
 public:
  inline ScalarArrayOpExpr() : ScalarArrayOpExpr(nullptr) {}
  virtual ~ScalarArrayOpExpr();

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

  inline ScalarArrayOpExpr& operator=(const ScalarArrayOpExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScalarArrayOpExpr& operator=(ScalarArrayOpExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ScalarArrayOpExpr& default_instance();

  static inline const ScalarArrayOpExpr* internal_default_instance() {
    return reinterpret_cast<const ScalarArrayOpExpr*>(
               &_ScalarArrayOpExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  friend void swap(ScalarArrayOpExpr& a, ScalarArrayOpExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(ScalarArrayOpExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScalarArrayOpExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ScalarArrayOpExpr* New() const final {
    return CreateMaybeMessage<ScalarArrayOpExpr>(nullptr);
  }

  ScalarArrayOpExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ScalarArrayOpExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ScalarArrayOpExpr& from);
  void MergeFrom(const ScalarArrayOpExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ScalarArrayOpExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ScalarArrayOpExpr";
  }
  protected:
  explicit ScalarArrayOpExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 6,
    kXprFieldNumber = 1,
    kOpnoFieldNumber = 2,
    kOpfuncidFieldNumber = 3,
    kUseOrFieldNumber = 4,
    kInputcollidFieldNumber = 5,
    kLocationFieldNumber = 7,
  };
  // repeated .pg_query.Node args = 6 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 opno = 2 [json_name = "opno"];
  void clear_opno();
  ::PROTOBUF_NAMESPACE_ID::uint32 opno() const;
  void set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opno() const;
  void _internal_set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 opfuncid = 3 [json_name = "opfuncid"];
  void clear_opfuncid();
  ::PROTOBUF_NAMESPACE_ID::uint32 opfuncid() const;
  void set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_opfuncid() const;
  void _internal_set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool use_or = 4 [json_name = "useOr"];
  void clear_use_or();
  bool use_or() const;
  void set_use_or(bool value);
  private:
  bool _internal_use_or() const;
  void _internal_set_use_or(bool value);
  public:

  // uint32 inputcollid = 5 [json_name = "inputcollid"];
  void clear_inputcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid() const;
  void set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_inputcollid() const;
  void _internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 location = 7 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ScalarArrayOpExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opno_;
  ::PROTOBUF_NAMESPACE_ID::uint32 opfuncid_;
  bool use_or_;
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class BoolExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.BoolExpr) */ {
 public:
  inline BoolExpr() : BoolExpr(nullptr) {}
  virtual ~BoolExpr();

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

  inline BoolExpr& operator=(const BoolExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline BoolExpr& operator=(BoolExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const BoolExpr& default_instance();

  static inline const BoolExpr* internal_default_instance() {
    return reinterpret_cast<const BoolExpr*>(
               &_BoolExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  friend void swap(BoolExpr& a, BoolExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(BoolExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BoolExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline BoolExpr* New() const final {
    return CreateMaybeMessage<BoolExpr>(nullptr);
  }

  BoolExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BoolExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BoolExpr& from);
  void MergeFrom(const BoolExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BoolExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.BoolExpr";
  }
  protected:
  explicit BoolExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 3,
    kXprFieldNumber = 1,
    kBoolopFieldNumber = 2,
    kLocationFieldNumber = 4,
  };
  // repeated .pg_query.Node args = 3 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.BoolExprType boolop = 2 [json_name = "boolop"];
  void clear_boolop();
  ::pg_query::BoolExprType boolop() const;
  void set_boolop(::pg_query::BoolExprType value);
  private:
  ::pg_query::BoolExprType _internal_boolop() const;
  void _internal_set_boolop(::pg_query::BoolExprType value);
  public:

  // int32 location = 4 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.BoolExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::pg_query::Node* xpr_;
  int boolop_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class SubLink PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SubLink) */ {
 public:
  inline SubLink() : SubLink(nullptr) {}
  virtual ~SubLink();

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

  inline SubLink& operator=(const SubLink& from) {
    CopyFrom(from);
    return *this;
  }
  inline SubLink& operator=(SubLink&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SubLink& default_instance();

  static inline const SubLink* internal_default_instance() {
    return reinterpret_cast<const SubLink*>(
               &_SubLink_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  friend void swap(SubLink& a, SubLink& b) {
    a.Swap(&b);
  }
  inline void Swap(SubLink* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SubLink* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SubLink* New() const final {
    return CreateMaybeMessage<SubLink>(nullptr);
  }

  SubLink* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SubLink>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SubLink& from);
  void MergeFrom(const SubLink& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SubLink* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.SubLink";
  }
  protected:
  explicit SubLink(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOperNameFieldNumber = 5,
    kXprFieldNumber = 1,
    kTestexprFieldNumber = 4,
    kSubselectFieldNumber = 6,
    kSubLinkTypeFieldNumber = 2,
    kSubLinkIdFieldNumber = 3,
    kLocationFieldNumber = 7,
  };
  // repeated .pg_query.Node oper_name = 5 [json_name = "operName"];
  int oper_name_size() const;
  private:
  int _internal_oper_name_size() const;
  public:
  void clear_oper_name();
  ::pg_query::Node* mutable_oper_name(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_oper_name();
  private:
  const ::pg_query::Node& _internal_oper_name(int index) const;
  ::pg_query::Node* _internal_add_oper_name();
  public:
  const ::pg_query::Node& oper_name(int index) const;
  ::pg_query::Node* add_oper_name();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      oper_name() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node testexpr = 4 [json_name = "testexpr"];
  bool has_testexpr() const;
  private:
  bool _internal_has_testexpr() const;
  public:
  void clear_testexpr();
  const ::pg_query::Node& testexpr() const;
  ::pg_query::Node* release_testexpr();
  ::pg_query::Node* mutable_testexpr();
  void set_allocated_testexpr(::pg_query::Node* testexpr);
  private:
  const ::pg_query::Node& _internal_testexpr() const;
  ::pg_query::Node* _internal_mutable_testexpr();
  public:
  void unsafe_arena_set_allocated_testexpr(
      ::pg_query::Node* testexpr);
  ::pg_query::Node* unsafe_arena_release_testexpr();

  // .pg_query.Node subselect = 6 [json_name = "subselect"];
  bool has_subselect() const;
  private:
  bool _internal_has_subselect() const;
  public:
  void clear_subselect();
  const ::pg_query::Node& subselect() const;
  ::pg_query::Node* release_subselect();
  ::pg_query::Node* mutable_subselect();
  void set_allocated_subselect(::pg_query::Node* subselect);
  private:
  const ::pg_query::Node& _internal_subselect() const;
  ::pg_query::Node* _internal_mutable_subselect();
  public:
  void unsafe_arena_set_allocated_subselect(
      ::pg_query::Node* subselect);
  ::pg_query::Node* unsafe_arena_release_subselect();

  // .pg_query.SubLinkType sub_link_type = 2 [json_name = "subLinkType"];
  void clear_sub_link_type();
  ::pg_query::SubLinkType sub_link_type() const;
  void set_sub_link_type(::pg_query::SubLinkType value);
  private:
  ::pg_query::SubLinkType _internal_sub_link_type() const;
  void _internal_set_sub_link_type(::pg_query::SubLinkType value);
  public:

  // int32 sub_link_id = 3 [json_name = "subLinkId"];
  void clear_sub_link_id();
  ::PROTOBUF_NAMESPACE_ID::int32 sub_link_id() const;
  void set_sub_link_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_sub_link_id() const;
  void _internal_set_sub_link_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 location = 7 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.SubLink)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > oper_name_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* testexpr_;
  ::pg_query::Node* subselect_;
  int sub_link_type_;
  ::PROTOBUF_NAMESPACE_ID::int32 sub_link_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class SubPlan PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SubPlan) */ {
 public:
  inline SubPlan() : SubPlan(nullptr) {}
  virtual ~SubPlan();

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

  inline SubPlan& operator=(const SubPlan& from) {
    CopyFrom(from);
    return *this;
  }
  inline SubPlan& operator=(SubPlan&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SubPlan& default_instance();

  static inline const SubPlan* internal_default_instance() {
    return reinterpret_cast<const SubPlan*>(
               &_SubPlan_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    30;

  friend void swap(SubPlan& a, SubPlan& b) {
    a.Swap(&b);
  }
  inline void Swap(SubPlan* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SubPlan* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SubPlan* New() const final {
    return CreateMaybeMessage<SubPlan>(nullptr);
  }

  SubPlan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SubPlan>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SubPlan& from);
  void MergeFrom(const SubPlan& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SubPlan* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.SubPlan";
  }
  protected:
  explicit SubPlan(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kParamIdsFieldNumber = 4,
    kSetParamFieldNumber = 13,
    kParParamFieldNumber = 14,
    kArgsFieldNumber = 15,
    kPlanNameFieldNumber = 6,
    kXprFieldNumber = 1,
    kTestexprFieldNumber = 3,
    kSubLinkTypeFieldNumber = 2,
    kPlanIdFieldNumber = 5,
    kFirstColTypeFieldNumber = 7,
    kFirstColTypmodFieldNumber = 8,
    kFirstColCollationFieldNumber = 9,
    kUseHashTableFieldNumber = 10,
    kUnknownEqFalseFieldNumber = 11,
    kParallelSafeFieldNumber = 12,
    kStartupCostFieldNumber = 16,
    kPerCallCostFieldNumber = 17,
  };
  // repeated .pg_query.Node param_ids = 4 [json_name = "paramIds"];
  int param_ids_size() const;
  private:
  int _internal_param_ids_size() const;
  public:
  void clear_param_ids();
  ::pg_query::Node* mutable_param_ids(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_param_ids();
  private:
  const ::pg_query::Node& _internal_param_ids(int index) const;
  ::pg_query::Node* _internal_add_param_ids();
  public:
  const ::pg_query::Node& param_ids(int index) const;
  ::pg_query::Node* add_param_ids();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      param_ids() const;

  // repeated .pg_query.Node set_param = 13 [json_name = "setParam"];
  int set_param_size() const;
  private:
  int _internal_set_param_size() const;
  public:
  void clear_set_param();
  ::pg_query::Node* mutable_set_param(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_set_param();
  private:
  const ::pg_query::Node& _internal_set_param(int index) const;
  ::pg_query::Node* _internal_add_set_param();
  public:
  const ::pg_query::Node& set_param(int index) const;
  ::pg_query::Node* add_set_param();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      set_param() const;

  // repeated .pg_query.Node par_param = 14 [json_name = "parParam"];
  int par_param_size() const;
  private:
  int _internal_par_param_size() const;
  public:
  void clear_par_param();
  ::pg_query::Node* mutable_par_param(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_par_param();
  private:
  const ::pg_query::Node& _internal_par_param(int index) const;
  ::pg_query::Node* _internal_add_par_param();
  public:
  const ::pg_query::Node& par_param(int index) const;
  ::pg_query::Node* add_par_param();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      par_param() const;

  // repeated .pg_query.Node args = 15 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // string plan_name = 6 [json_name = "plan_name"];
  void clear_plan_name();
  const std::string& plan_name() const;
  void set_plan_name(const std::string& value);
  void set_plan_name(std::string&& value);
  void set_plan_name(const char* value);
  void set_plan_name(const char* value, size_t size);
  std::string* mutable_plan_name();
  std::string* release_plan_name();
  void set_allocated_plan_name(std::string* plan_name);
  private:
  const std::string& _internal_plan_name() const;
  void _internal_set_plan_name(const std::string& value);
  std::string* _internal_mutable_plan_name();
  public:

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node testexpr = 3 [json_name = "testexpr"];
  bool has_testexpr() const;
  private:
  bool _internal_has_testexpr() const;
  public:
  void clear_testexpr();
  const ::pg_query::Node& testexpr() const;
  ::pg_query::Node* release_testexpr();
  ::pg_query::Node* mutable_testexpr();
  void set_allocated_testexpr(::pg_query::Node* testexpr);
  private:
  const ::pg_query::Node& _internal_testexpr() const;
  ::pg_query::Node* _internal_mutable_testexpr();
  public:
  void unsafe_arena_set_allocated_testexpr(
      ::pg_query::Node* testexpr);
  ::pg_query::Node* unsafe_arena_release_testexpr();

  // .pg_query.SubLinkType sub_link_type = 2 [json_name = "subLinkType"];
  void clear_sub_link_type();
  ::pg_query::SubLinkType sub_link_type() const;
  void set_sub_link_type(::pg_query::SubLinkType value);
  private:
  ::pg_query::SubLinkType _internal_sub_link_type() const;
  void _internal_set_sub_link_type(::pg_query::SubLinkType value);
  public:

  // int32 plan_id = 5 [json_name = "plan_id"];
  void clear_plan_id();
  ::PROTOBUF_NAMESPACE_ID::int32 plan_id() const;
  void set_plan_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_plan_id() const;
  void _internal_set_plan_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 first_col_type = 7 [json_name = "firstColType"];
  void clear_first_col_type();
  ::PROTOBUF_NAMESPACE_ID::uint32 first_col_type() const;
  void set_first_col_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_first_col_type() const;
  void _internal_set_first_col_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 first_col_typmod = 8 [json_name = "firstColTypmod"];
  void clear_first_col_typmod();
  ::PROTOBUF_NAMESPACE_ID::int32 first_col_typmod() const;
  void set_first_col_typmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_first_col_typmod() const;
  void _internal_set_first_col_typmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 first_col_collation = 9 [json_name = "firstColCollation"];
  void clear_first_col_collation();
  ::PROTOBUF_NAMESPACE_ID::uint32 first_col_collation() const;
  void set_first_col_collation(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_first_col_collation() const;
  void _internal_set_first_col_collation(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool use_hash_table = 10 [json_name = "useHashTable"];
  void clear_use_hash_table();
  bool use_hash_table() const;
  void set_use_hash_table(bool value);
  private:
  bool _internal_use_hash_table() const;
  void _internal_set_use_hash_table(bool value);
  public:

  // bool unknown_eq_false = 11 [json_name = "unknownEqFalse"];
  void clear_unknown_eq_false();
  bool unknown_eq_false() const;
  void set_unknown_eq_false(bool value);
  private:
  bool _internal_unknown_eq_false() const;
  void _internal_set_unknown_eq_false(bool value);
  public:

  // bool parallel_safe = 12 [json_name = "parallel_safe"];
  void clear_parallel_safe();
  bool parallel_safe() const;
  void set_parallel_safe(bool value);
  private:
  bool _internal_parallel_safe() const;
  void _internal_set_parallel_safe(bool value);
  public:

  // double startup_cost = 16 [json_name = "startup_cost"];
  void clear_startup_cost();
  double startup_cost() const;
  void set_startup_cost(double value);
  private:
  double _internal_startup_cost() const;
  void _internal_set_startup_cost(double value);
  public:

  // double per_call_cost = 17 [json_name = "per_call_cost"];
  void clear_per_call_cost();
  double per_call_cost() const;
  void set_per_call_cost(double value);
  private:
  double _internal_per_call_cost() const;
  void _internal_set_per_call_cost(double value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.SubPlan)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > param_ids_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > set_param_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > par_param_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr plan_name_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* testexpr_;
  int sub_link_type_;
  ::PROTOBUF_NAMESPACE_ID::int32 plan_id_;
  ::PROTOBUF_NAMESPACE_ID::uint32 first_col_type_;
  ::PROTOBUF_NAMESPACE_ID::int32 first_col_typmod_;
  ::PROTOBUF_NAMESPACE_ID::uint32 first_col_collation_;
  bool use_hash_table_;
  bool unknown_eq_false_;
  bool parallel_safe_;
  double startup_cost_;
  double per_call_cost_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlternativeSubPlan PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlternativeSubPlan) */ {
 public:
  inline AlternativeSubPlan() : AlternativeSubPlan(nullptr) {}
  virtual ~AlternativeSubPlan();

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

  inline AlternativeSubPlan& operator=(const AlternativeSubPlan& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlternativeSubPlan& operator=(AlternativeSubPlan&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlternativeSubPlan& default_instance();

  static inline const AlternativeSubPlan* internal_default_instance() {
    return reinterpret_cast<const AlternativeSubPlan*>(
               &_AlternativeSubPlan_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    31;

  friend void swap(AlternativeSubPlan& a, AlternativeSubPlan& b) {
    a.Swap(&b);
  }
  inline void Swap(AlternativeSubPlan* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlternativeSubPlan* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlternativeSubPlan* New() const final {
    return CreateMaybeMessage<AlternativeSubPlan>(nullptr);
  }

  AlternativeSubPlan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlternativeSubPlan>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlternativeSubPlan& from);
  void MergeFrom(const AlternativeSubPlan& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlternativeSubPlan* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlternativeSubPlan";
  }
  protected:
  explicit AlternativeSubPlan(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSubplansFieldNumber = 2,
    kXprFieldNumber = 1,
  };
  // repeated .pg_query.Node subplans = 2 [json_name = "subplans"];
  int subplans_size() const;
  private:
  int _internal_subplans_size() const;
  public:
  void clear_subplans();
  ::pg_query::Node* mutable_subplans(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_subplans();
  private:
  const ::pg_query::Node& _internal_subplans(int index) const;
  ::pg_query::Node* _internal_add_subplans();
  public:
  const ::pg_query::Node& subplans(int index) const;
  ::pg_query::Node* add_subplans();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      subplans() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // @@protoc_insertion_point(class_scope:pg_query.AlternativeSubPlan)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > subplans_;
  ::pg_query::Node* xpr_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class FieldSelect PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FieldSelect) */ {
 public:
  inline FieldSelect() : FieldSelect(nullptr) {}
  virtual ~FieldSelect();

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

  inline FieldSelect& operator=(const FieldSelect& from) {
    CopyFrom(from);
    return *this;
  }
  inline FieldSelect& operator=(FieldSelect&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const FieldSelect& default_instance();

  static inline const FieldSelect* internal_default_instance() {
    return reinterpret_cast<const FieldSelect*>(
               &_FieldSelect_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    32;

  friend void swap(FieldSelect& a, FieldSelect& b) {
    a.Swap(&b);
  }
  inline void Swap(FieldSelect* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FieldSelect* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline FieldSelect* New() const final {
    return CreateMaybeMessage<FieldSelect>(nullptr);
  }

  FieldSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FieldSelect>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const FieldSelect& from);
  void MergeFrom(const FieldSelect& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FieldSelect* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.FieldSelect";
  }
  protected:
  explicit FieldSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kArgFieldNumber = 2,
    kFieldnumFieldNumber = 3,
    kResulttypeFieldNumber = 4,
    kResulttypmodFieldNumber = 5,
    kResultcollidFieldNumber = 6,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // int32 fieldnum = 3 [json_name = "fieldnum"];
  void clear_fieldnum();
  ::PROTOBUF_NAMESPACE_ID::int32 fieldnum() const;
  void set_fieldnum(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_fieldnum() const;
  void _internal_set_fieldnum(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 resulttype = 4 [json_name = "resulttype"];
  void clear_resulttype();
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype() const;
  void set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resulttype() const;
  void _internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 resulttypmod = 5 [json_name = "resulttypmod"];
  void clear_resulttypmod();
  ::PROTOBUF_NAMESPACE_ID::int32 resulttypmod() const;
  void set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_resulttypmod() const;
  void _internal_set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 resultcollid = 6 [json_name = "resultcollid"];
  void clear_resultcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 resultcollid() const;
  void set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resultcollid() const;
  void _internal_set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.FieldSelect)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* arg_;
  ::PROTOBUF_NAMESPACE_ID::int32 fieldnum_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype_;
  ::PROTOBUF_NAMESPACE_ID::int32 resulttypmod_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resultcollid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class FieldStore PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FieldStore) */ {
 public:
  inline FieldStore() : FieldStore(nullptr) {}
  virtual ~FieldStore();

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

  inline FieldStore& operator=(const FieldStore& from) {
    CopyFrom(from);
    return *this;
  }
  inline FieldStore& operator=(FieldStore&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const FieldStore& default_instance();

  static inline const FieldStore* internal_default_instance() {
    return reinterpret_cast<const FieldStore*>(
               &_FieldStore_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    33;

  friend void swap(FieldStore& a, FieldStore& b) {
    a.Swap(&b);
  }
  inline void Swap(FieldStore* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FieldStore* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline FieldStore* New() const final {
    return CreateMaybeMessage<FieldStore>(nullptr);
  }

  FieldStore* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FieldStore>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const FieldStore& from);
  void MergeFrom(const FieldStore& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FieldStore* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.FieldStore";
  }
  protected:
  explicit FieldStore(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNewvalsFieldNumber = 3,
    kFieldnumsFieldNumber = 4,
    kXprFieldNumber = 1,
    kArgFieldNumber = 2,
    kResulttypeFieldNumber = 5,
  };
  // repeated .pg_query.Node newvals = 3 [json_name = "newvals"];
  int newvals_size() const;
  private:
  int _internal_newvals_size() const;
  public:
  void clear_newvals();
  ::pg_query::Node* mutable_newvals(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_newvals();
  private:
  const ::pg_query::Node& _internal_newvals(int index) const;
  ::pg_query::Node* _internal_add_newvals();
  public:
  const ::pg_query::Node& newvals(int index) const;
  ::pg_query::Node* add_newvals();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      newvals() const;

  // repeated .pg_query.Node fieldnums = 4 [json_name = "fieldnums"];
  int fieldnums_size() const;
  private:
  int _internal_fieldnums_size() const;
  public:
  void clear_fieldnums();
  ::pg_query::Node* mutable_fieldnums(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_fieldnums();
  private:
  const ::pg_query::Node& _internal_fieldnums(int index) const;
  ::pg_query::Node* _internal_add_fieldnums();
  public:
  const ::pg_query::Node& fieldnums(int index) const;
  ::pg_query::Node* add_fieldnums();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      fieldnums() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // uint32 resulttype = 5 [json_name = "resulttype"];
  void clear_resulttype();
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype() const;
  void set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resulttype() const;
  void _internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.FieldStore)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > newvals_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > fieldnums_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* arg_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RelabelType PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RelabelType) */ {
 public:
  inline RelabelType() : RelabelType(nullptr) {}
  virtual ~RelabelType();

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

  inline RelabelType& operator=(const RelabelType& from) {
    CopyFrom(from);
    return *this;
  }
  inline RelabelType& operator=(RelabelType&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RelabelType& default_instance();

  static inline const RelabelType* internal_default_instance() {
    return reinterpret_cast<const RelabelType*>(
               &_RelabelType_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    34;

  friend void swap(RelabelType& a, RelabelType& b) {
    a.Swap(&b);
  }
  inline void Swap(RelabelType* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RelabelType* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline RelabelType* New() const final {
    return CreateMaybeMessage<RelabelType>(nullptr);
  }

  RelabelType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RelabelType>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RelabelType& from);
  void MergeFrom(const RelabelType& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RelabelType* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RelabelType";
  }
  protected:
  explicit RelabelType(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kArgFieldNumber = 2,
    kResulttypeFieldNumber = 3,
    kResulttypmodFieldNumber = 4,
    kResultcollidFieldNumber = 5,
    kRelabelformatFieldNumber = 6,
    kLocationFieldNumber = 7,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // uint32 resulttype = 3 [json_name = "resulttype"];
  void clear_resulttype();
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype() const;
  void set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resulttype() const;
  void _internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 resulttypmod = 4 [json_name = "resulttypmod"];
  void clear_resulttypmod();
  ::PROTOBUF_NAMESPACE_ID::int32 resulttypmod() const;
  void set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_resulttypmod() const;
  void _internal_set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 resultcollid = 5 [json_name = "resultcollid"];
  void clear_resultcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 resultcollid() const;
  void set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resultcollid() const;
  void _internal_set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .pg_query.CoercionForm relabelformat = 6 [json_name = "relabelformat"];
  void clear_relabelformat();
  ::pg_query::CoercionForm relabelformat() const;
  void set_relabelformat(::pg_query::CoercionForm value);
  private:
  ::pg_query::CoercionForm _internal_relabelformat() const;
  void _internal_set_relabelformat(::pg_query::CoercionForm value);
  public:

  // int32 location = 7 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RelabelType)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* arg_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype_;
  ::PROTOBUF_NAMESPACE_ID::int32 resulttypmod_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resultcollid_;
  int relabelformat_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CoerceViaIO PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CoerceViaIO) */ {
 public:
  inline CoerceViaIO() : CoerceViaIO(nullptr) {}
  virtual ~CoerceViaIO();

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

  inline CoerceViaIO& operator=(const CoerceViaIO& from) {
    CopyFrom(from);
    return *this;
  }
  inline CoerceViaIO& operator=(CoerceViaIO&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CoerceViaIO& default_instance();

  static inline const CoerceViaIO* internal_default_instance() {
    return reinterpret_cast<const CoerceViaIO*>(
               &_CoerceViaIO_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    35;

  friend void swap(CoerceViaIO& a, CoerceViaIO& b) {
    a.Swap(&b);
  }
  inline void Swap(CoerceViaIO* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CoerceViaIO* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CoerceViaIO* New() const final {
    return CreateMaybeMessage<CoerceViaIO>(nullptr);
  }

  CoerceViaIO* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CoerceViaIO>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CoerceViaIO& from);
  void MergeFrom(const CoerceViaIO& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CoerceViaIO* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CoerceViaIO";
  }
  protected:
  explicit CoerceViaIO(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kArgFieldNumber = 2,
    kResulttypeFieldNumber = 3,
    kResultcollidFieldNumber = 4,
    kCoerceformatFieldNumber = 5,
    kLocationFieldNumber = 6,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // uint32 resulttype = 3 [json_name = "resulttype"];
  void clear_resulttype();
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype() const;
  void set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resulttype() const;
  void _internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 resultcollid = 4 [json_name = "resultcollid"];
  void clear_resultcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 resultcollid() const;
  void set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resultcollid() const;
  void _internal_set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .pg_query.CoercionForm coerceformat = 5 [json_name = "coerceformat"];
  void clear_coerceformat();
  ::pg_query::CoercionForm coerceformat() const;
  void set_coerceformat(::pg_query::CoercionForm value);
  private:
  ::pg_query::CoercionForm _internal_coerceformat() const;
  void _internal_set_coerceformat(::pg_query::CoercionForm value);
  public:

  // int32 location = 6 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CoerceViaIO)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* arg_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resultcollid_;
  int coerceformat_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ArrayCoerceExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ArrayCoerceExpr) */ {
 public:
  inline ArrayCoerceExpr() : ArrayCoerceExpr(nullptr) {}
  virtual ~ArrayCoerceExpr();

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

  inline ArrayCoerceExpr& operator=(const ArrayCoerceExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline ArrayCoerceExpr& operator=(ArrayCoerceExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ArrayCoerceExpr& default_instance();

  static inline const ArrayCoerceExpr* internal_default_instance() {
    return reinterpret_cast<const ArrayCoerceExpr*>(
               &_ArrayCoerceExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    36;

  friend void swap(ArrayCoerceExpr& a, ArrayCoerceExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(ArrayCoerceExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ArrayCoerceExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ArrayCoerceExpr* New() const final {
    return CreateMaybeMessage<ArrayCoerceExpr>(nullptr);
  }

  ArrayCoerceExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ArrayCoerceExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ArrayCoerceExpr& from);
  void MergeFrom(const ArrayCoerceExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ArrayCoerceExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ArrayCoerceExpr";
  }
  protected:
  explicit ArrayCoerceExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kArgFieldNumber = 2,
    kElemexprFieldNumber = 3,
    kResulttypeFieldNumber = 4,
    kResulttypmodFieldNumber = 5,
    kResultcollidFieldNumber = 6,
    kCoerceformatFieldNumber = 7,
    kLocationFieldNumber = 8,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // .pg_query.Node elemexpr = 3 [json_name = "elemexpr"];
  bool has_elemexpr() const;
  private:
  bool _internal_has_elemexpr() const;
  public:
  void clear_elemexpr();
  const ::pg_query::Node& elemexpr() const;
  ::pg_query::Node* release_elemexpr();
  ::pg_query::Node* mutable_elemexpr();
  void set_allocated_elemexpr(::pg_query::Node* elemexpr);
  private:
  const ::pg_query::Node& _internal_elemexpr() const;
  ::pg_query::Node* _internal_mutable_elemexpr();
  public:
  void unsafe_arena_set_allocated_elemexpr(
      ::pg_query::Node* elemexpr);
  ::pg_query::Node* unsafe_arena_release_elemexpr();

  // uint32 resulttype = 4 [json_name = "resulttype"];
  void clear_resulttype();
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype() const;
  void set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resulttype() const;
  void _internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 resulttypmod = 5 [json_name = "resulttypmod"];
  void clear_resulttypmod();
  ::PROTOBUF_NAMESPACE_ID::int32 resulttypmod() const;
  void set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_resulttypmod() const;
  void _internal_set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 resultcollid = 6 [json_name = "resultcollid"];
  void clear_resultcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 resultcollid() const;
  void set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resultcollid() const;
  void _internal_set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .pg_query.CoercionForm coerceformat = 7 [json_name = "coerceformat"];
  void clear_coerceformat();
  ::pg_query::CoercionForm coerceformat() const;
  void set_coerceformat(::pg_query::CoercionForm value);
  private:
  ::pg_query::CoercionForm _internal_coerceformat() const;
  void _internal_set_coerceformat(::pg_query::CoercionForm value);
  public:

  // int32 location = 8 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ArrayCoerceExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* arg_;
  ::pg_query::Node* elemexpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype_;
  ::PROTOBUF_NAMESPACE_ID::int32 resulttypmod_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resultcollid_;
  int coerceformat_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ConvertRowtypeExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ConvertRowtypeExpr) */ {
 public:
  inline ConvertRowtypeExpr() : ConvertRowtypeExpr(nullptr) {}
  virtual ~ConvertRowtypeExpr();

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

  inline ConvertRowtypeExpr& operator=(const ConvertRowtypeExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConvertRowtypeExpr& operator=(ConvertRowtypeExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ConvertRowtypeExpr& default_instance();

  static inline const ConvertRowtypeExpr* internal_default_instance() {
    return reinterpret_cast<const ConvertRowtypeExpr*>(
               &_ConvertRowtypeExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    37;

  friend void swap(ConvertRowtypeExpr& a, ConvertRowtypeExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(ConvertRowtypeExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ConvertRowtypeExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ConvertRowtypeExpr* New() const final {
    return CreateMaybeMessage<ConvertRowtypeExpr>(nullptr);
  }

  ConvertRowtypeExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ConvertRowtypeExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ConvertRowtypeExpr& from);
  void MergeFrom(const ConvertRowtypeExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ConvertRowtypeExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ConvertRowtypeExpr";
  }
  protected:
  explicit ConvertRowtypeExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kArgFieldNumber = 2,
    kResulttypeFieldNumber = 3,
    kConvertformatFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // uint32 resulttype = 3 [json_name = "resulttype"];
  void clear_resulttype();
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype() const;
  void set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resulttype() const;
  void _internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .pg_query.CoercionForm convertformat = 4 [json_name = "convertformat"];
  void clear_convertformat();
  ::pg_query::CoercionForm convertformat() const;
  void set_convertformat(::pg_query::CoercionForm value);
  private:
  ::pg_query::CoercionForm _internal_convertformat() const;
  void _internal_set_convertformat(::pg_query::CoercionForm value);
  public:

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ConvertRowtypeExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* arg_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype_;
  int convertformat_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CollateExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CollateExpr) */ {
 public:
  inline CollateExpr() : CollateExpr(nullptr) {}
  virtual ~CollateExpr();

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

  inline CollateExpr& operator=(const CollateExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline CollateExpr& operator=(CollateExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CollateExpr& default_instance();

  static inline const CollateExpr* internal_default_instance() {
    return reinterpret_cast<const CollateExpr*>(
               &_CollateExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    38;

  friend void swap(CollateExpr& a, CollateExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(CollateExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CollateExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CollateExpr* New() const final {
    return CreateMaybeMessage<CollateExpr>(nullptr);
  }

  CollateExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CollateExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CollateExpr& from);
  void MergeFrom(const CollateExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CollateExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CollateExpr";
  }
  protected:
  explicit CollateExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kArgFieldNumber = 2,
    kCollOidFieldNumber = 3,
    kLocationFieldNumber = 4,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // uint32 coll_oid = 3 [json_name = "collOid"];
  void clear_coll_oid();
  ::PROTOBUF_NAMESPACE_ID::uint32 coll_oid() const;
  void set_coll_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_coll_oid() const;
  void _internal_set_coll_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 location = 4 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CollateExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* arg_;
  ::PROTOBUF_NAMESPACE_ID::uint32 coll_oid_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CaseExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CaseExpr) */ {
 public:
  inline CaseExpr() : CaseExpr(nullptr) {}
  virtual ~CaseExpr();

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

  inline CaseExpr& operator=(const CaseExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline CaseExpr& operator=(CaseExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CaseExpr& default_instance();

  static inline const CaseExpr* internal_default_instance() {
    return reinterpret_cast<const CaseExpr*>(
               &_CaseExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    39;

  friend void swap(CaseExpr& a, CaseExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(CaseExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CaseExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CaseExpr* New() const final {
    return CreateMaybeMessage<CaseExpr>(nullptr);
  }

  CaseExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CaseExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CaseExpr& from);
  void MergeFrom(const CaseExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CaseExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CaseExpr";
  }
  protected:
  explicit CaseExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 5,
    kXprFieldNumber = 1,
    kArgFieldNumber = 4,
    kDefresultFieldNumber = 6,
    kCasetypeFieldNumber = 2,
    kCasecollidFieldNumber = 3,
    kLocationFieldNumber = 7,
  };
  // repeated .pg_query.Node args = 5 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node arg = 4 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // .pg_query.Node defresult = 6 [json_name = "defresult"];
  bool has_defresult() const;
  private:
  bool _internal_has_defresult() const;
  public:
  void clear_defresult();
  const ::pg_query::Node& defresult() const;
  ::pg_query::Node* release_defresult();
  ::pg_query::Node* mutable_defresult();
  void set_allocated_defresult(::pg_query::Node* defresult);
  private:
  const ::pg_query::Node& _internal_defresult() const;
  ::pg_query::Node* _internal_mutable_defresult();
  public:
  void unsafe_arena_set_allocated_defresult(
      ::pg_query::Node* defresult);
  ::pg_query::Node* unsafe_arena_release_defresult();

  // uint32 casetype = 2 [json_name = "casetype"];
  void clear_casetype();
  ::PROTOBUF_NAMESPACE_ID::uint32 casetype() const;
  void set_casetype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_casetype() const;
  void _internal_set_casetype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 casecollid = 3 [json_name = "casecollid"];
  void clear_casecollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 casecollid() const;
  void set_casecollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_casecollid() const;
  void _internal_set_casecollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 location = 7 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CaseExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* arg_;
  ::pg_query::Node* defresult_;
  ::PROTOBUF_NAMESPACE_ID::uint32 casetype_;
  ::PROTOBUF_NAMESPACE_ID::uint32 casecollid_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CaseWhen PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CaseWhen) */ {
 public:
  inline CaseWhen() : CaseWhen(nullptr) {}
  virtual ~CaseWhen();

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

  inline CaseWhen& operator=(const CaseWhen& from) {
    CopyFrom(from);
    return *this;
  }
  inline CaseWhen& operator=(CaseWhen&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CaseWhen& default_instance();

  static inline const CaseWhen* internal_default_instance() {
    return reinterpret_cast<const CaseWhen*>(
               &_CaseWhen_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    40;

  friend void swap(CaseWhen& a, CaseWhen& b) {
    a.Swap(&b);
  }
  inline void Swap(CaseWhen* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CaseWhen* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CaseWhen* New() const final {
    return CreateMaybeMessage<CaseWhen>(nullptr);
  }

  CaseWhen* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CaseWhen>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CaseWhen& from);
  void MergeFrom(const CaseWhen& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CaseWhen* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CaseWhen";
  }
  protected:
  explicit CaseWhen(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kExprFieldNumber = 2,
    kResultFieldNumber = 3,
    kLocationFieldNumber = 4,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node expr = 2 [json_name = "expr"];
  bool has_expr() const;
  private:
  bool _internal_has_expr() const;
  public:
  void clear_expr();
  const ::pg_query::Node& expr() const;
  ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* expr);
  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();
  public:
  void unsafe_arena_set_allocated_expr(
      ::pg_query::Node* expr);
  ::pg_query::Node* unsafe_arena_release_expr();

  // .pg_query.Node result = 3 [json_name = "result"];
  bool has_result() const;
  private:
  bool _internal_has_result() const;
  public:
  void clear_result();
  const ::pg_query::Node& result() const;
  ::pg_query::Node* release_result();
  ::pg_query::Node* mutable_result();
  void set_allocated_result(::pg_query::Node* result);
  private:
  const ::pg_query::Node& _internal_result() const;
  ::pg_query::Node* _internal_mutable_result();
  public:
  void unsafe_arena_set_allocated_result(
      ::pg_query::Node* result);
  ::pg_query::Node* unsafe_arena_release_result();

  // int32 location = 4 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CaseWhen)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* expr_;
  ::pg_query::Node* result_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CaseTestExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CaseTestExpr) */ {
 public:
  inline CaseTestExpr() : CaseTestExpr(nullptr) {}
  virtual ~CaseTestExpr();

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

  inline CaseTestExpr& operator=(const CaseTestExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline CaseTestExpr& operator=(CaseTestExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CaseTestExpr& default_instance();

  static inline const CaseTestExpr* internal_default_instance() {
    return reinterpret_cast<const CaseTestExpr*>(
               &_CaseTestExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    41;

  friend void swap(CaseTestExpr& a, CaseTestExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(CaseTestExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CaseTestExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CaseTestExpr* New() const final {
    return CreateMaybeMessage<CaseTestExpr>(nullptr);
  }

  CaseTestExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CaseTestExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CaseTestExpr& from);
  void MergeFrom(const CaseTestExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CaseTestExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CaseTestExpr";
  }
  protected:
  explicit CaseTestExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kTypeIdFieldNumber = 2,
    kTypeModFieldNumber = 3,
    kCollationFieldNumber = 4,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 type_id = 2 [json_name = "typeId"];
  void clear_type_id();
  ::PROTOBUF_NAMESPACE_ID::uint32 type_id() const;
  void set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_id() const;
  void _internal_set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 type_mod = 3 [json_name = "typeMod"];
  void clear_type_mod();
  ::PROTOBUF_NAMESPACE_ID::int32 type_mod() const;
  void set_type_mod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_type_mod() const;
  void _internal_set_type_mod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 collation = 4 [json_name = "collation"];
  void clear_collation();
  ::PROTOBUF_NAMESPACE_ID::uint32 collation() const;
  void set_collation(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_collation() const;
  void _internal_set_collation(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CaseTestExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 type_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 type_mod_;
  ::PROTOBUF_NAMESPACE_ID::uint32 collation_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ArrayExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ArrayExpr) */ {
 public:
  inline ArrayExpr() : ArrayExpr(nullptr) {}
  virtual ~ArrayExpr();

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

  inline ArrayExpr& operator=(const ArrayExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline ArrayExpr& operator=(ArrayExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ArrayExpr& default_instance();

  static inline const ArrayExpr* internal_default_instance() {
    return reinterpret_cast<const ArrayExpr*>(
               &_ArrayExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    42;

  friend void swap(ArrayExpr& a, ArrayExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(ArrayExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ArrayExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ArrayExpr* New() const final {
    return CreateMaybeMessage<ArrayExpr>(nullptr);
  }

  ArrayExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ArrayExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ArrayExpr& from);
  void MergeFrom(const ArrayExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ArrayExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ArrayExpr";
  }
  protected:
  explicit ArrayExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kElementsFieldNumber = 5,
    kXprFieldNumber = 1,
    kArrayTypeidFieldNumber = 2,
    kArrayCollidFieldNumber = 3,
    kElementTypeidFieldNumber = 4,
    kMultidimsFieldNumber = 6,
    kLocationFieldNumber = 7,
  };
  // repeated .pg_query.Node elements = 5 [json_name = "elements"];
  int elements_size() const;
  private:
  int _internal_elements_size() const;
  public:
  void clear_elements();
  ::pg_query::Node* mutable_elements(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_elements();
  private:
  const ::pg_query::Node& _internal_elements(int index) const;
  ::pg_query::Node* _internal_add_elements();
  public:
  const ::pg_query::Node& elements(int index) const;
  ::pg_query::Node* add_elements();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      elements() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 array_typeid = 2 [json_name = "array_typeid"];
  void clear_array_typeid();
  ::PROTOBUF_NAMESPACE_ID::uint32 array_typeid() const;
  void set_array_typeid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_array_typeid() const;
  void _internal_set_array_typeid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 array_collid = 3 [json_name = "array_collid"];
  void clear_array_collid();
  ::PROTOBUF_NAMESPACE_ID::uint32 array_collid() const;
  void set_array_collid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_array_collid() const;
  void _internal_set_array_collid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 element_typeid = 4 [json_name = "element_typeid"];
  void clear_element_typeid();
  ::PROTOBUF_NAMESPACE_ID::uint32 element_typeid() const;
  void set_element_typeid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_element_typeid() const;
  void _internal_set_element_typeid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool multidims = 6 [json_name = "multidims"];
  void clear_multidims();
  bool multidims() const;
  void set_multidims(bool value);
  private:
  bool _internal_multidims() const;
  void _internal_set_multidims(bool value);
  public:

  // int32 location = 7 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ArrayExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > elements_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 array_typeid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 array_collid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 element_typeid_;
  bool multidims_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RowExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RowExpr) */ {
 public:
  inline RowExpr() : RowExpr(nullptr) {}
  virtual ~RowExpr();

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

  inline RowExpr& operator=(const RowExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline RowExpr& operator=(RowExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RowExpr& default_instance();

  static inline const RowExpr* internal_default_instance() {
    return reinterpret_cast<const RowExpr*>(
               &_RowExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    43;

  friend void swap(RowExpr& a, RowExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(RowExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RowExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline RowExpr* New() const final {
    return CreateMaybeMessage<RowExpr>(nullptr);
  }

  RowExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RowExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RowExpr& from);
  void MergeFrom(const RowExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RowExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RowExpr";
  }
  protected:
  explicit RowExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 2,
    kColnamesFieldNumber = 5,
    kXprFieldNumber = 1,
    kRowTypeidFieldNumber = 3,
    kRowFormatFieldNumber = 4,
    kLocationFieldNumber = 6,
  };
  // repeated .pg_query.Node args = 2 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // repeated .pg_query.Node colnames = 5 [json_name = "colnames"];
  int colnames_size() const;
  private:
  int _internal_colnames_size() const;
  public:
  void clear_colnames();
  ::pg_query::Node* mutable_colnames(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_colnames();
  private:
  const ::pg_query::Node& _internal_colnames(int index) const;
  ::pg_query::Node* _internal_add_colnames();
  public:
  const ::pg_query::Node& colnames(int index) const;
  ::pg_query::Node* add_colnames();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      colnames() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 row_typeid = 3 [json_name = "row_typeid"];
  void clear_row_typeid();
  ::PROTOBUF_NAMESPACE_ID::uint32 row_typeid() const;
  void set_row_typeid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_row_typeid() const;
  void _internal_set_row_typeid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .pg_query.CoercionForm row_format = 4 [json_name = "row_format"];
  void clear_row_format();
  ::pg_query::CoercionForm row_format() const;
  void set_row_format(::pg_query::CoercionForm value);
  private:
  ::pg_query::CoercionForm _internal_row_format() const;
  void _internal_set_row_format(::pg_query::CoercionForm value);
  public:

  // int32 location = 6 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RowExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > colnames_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 row_typeid_;
  int row_format_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RowCompareExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RowCompareExpr) */ {
 public:
  inline RowCompareExpr() : RowCompareExpr(nullptr) {}
  virtual ~RowCompareExpr();

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

  inline RowCompareExpr& operator=(const RowCompareExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline RowCompareExpr& operator=(RowCompareExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RowCompareExpr& default_instance();

  static inline const RowCompareExpr* internal_default_instance() {
    return reinterpret_cast<const RowCompareExpr*>(
               &_RowCompareExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    44;

  friend void swap(RowCompareExpr& a, RowCompareExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(RowCompareExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RowCompareExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline RowCompareExpr* New() const final {
    return CreateMaybeMessage<RowCompareExpr>(nullptr);
  }

  RowCompareExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RowCompareExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RowCompareExpr& from);
  void MergeFrom(const RowCompareExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RowCompareExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RowCompareExpr";
  }
  protected:
  explicit RowCompareExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOpnosFieldNumber = 3,
    kOpfamiliesFieldNumber = 4,
    kInputcollidsFieldNumber = 5,
    kLargsFieldNumber = 6,
    kRargsFieldNumber = 7,
    kXprFieldNumber = 1,
    kRctypeFieldNumber = 2,
  };
  // repeated .pg_query.Node opnos = 3 [json_name = "opnos"];
  int opnos_size() const;
  private:
  int _internal_opnos_size() const;
  public:
  void clear_opnos();
  ::pg_query::Node* mutable_opnos(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_opnos();
  private:
  const ::pg_query::Node& _internal_opnos(int index) const;
  ::pg_query::Node* _internal_add_opnos();
  public:
  const ::pg_query::Node& opnos(int index) const;
  ::pg_query::Node* add_opnos();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      opnos() const;

  // repeated .pg_query.Node opfamilies = 4 [json_name = "opfamilies"];
  int opfamilies_size() const;
  private:
  int _internal_opfamilies_size() const;
  public:
  void clear_opfamilies();
  ::pg_query::Node* mutable_opfamilies(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_opfamilies();
  private:
  const ::pg_query::Node& _internal_opfamilies(int index) const;
  ::pg_query::Node* _internal_add_opfamilies();
  public:
  const ::pg_query::Node& opfamilies(int index) const;
  ::pg_query::Node* add_opfamilies();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      opfamilies() const;

  // repeated .pg_query.Node inputcollids = 5 [json_name = "inputcollids"];
  int inputcollids_size() const;
  private:
  int _internal_inputcollids_size() const;
  public:
  void clear_inputcollids();
  ::pg_query::Node* mutable_inputcollids(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_inputcollids();
  private:
  const ::pg_query::Node& _internal_inputcollids(int index) const;
  ::pg_query::Node* _internal_add_inputcollids();
  public:
  const ::pg_query::Node& inputcollids(int index) const;
  ::pg_query::Node* add_inputcollids();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      inputcollids() const;

  // repeated .pg_query.Node largs = 6 [json_name = "largs"];
  int largs_size() const;
  private:
  int _internal_largs_size() const;
  public:
  void clear_largs();
  ::pg_query::Node* mutable_largs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_largs();
  private:
  const ::pg_query::Node& _internal_largs(int index) const;
  ::pg_query::Node* _internal_add_largs();
  public:
  const ::pg_query::Node& largs(int index) const;
  ::pg_query::Node* add_largs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      largs() const;

  // repeated .pg_query.Node rargs = 7 [json_name = "rargs"];
  int rargs_size() const;
  private:
  int _internal_rargs_size() const;
  public:
  void clear_rargs();
  ::pg_query::Node* mutable_rargs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_rargs();
  private:
  const ::pg_query::Node& _internal_rargs(int index) const;
  ::pg_query::Node* _internal_add_rargs();
  public:
  const ::pg_query::Node& rargs(int index) const;
  ::pg_query::Node* add_rargs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      rargs() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.RowCompareType rctype = 2 [json_name = "rctype"];
  void clear_rctype();
  ::pg_query::RowCompareType rctype() const;
  void set_rctype(::pg_query::RowCompareType value);
  private:
  ::pg_query::RowCompareType _internal_rctype() const;
  void _internal_set_rctype(::pg_query::RowCompareType value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RowCompareExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opnos_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opfamilies_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > inputcollids_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > largs_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > rargs_;
  ::pg_query::Node* xpr_;
  int rctype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CoalesceExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CoalesceExpr) */ {
 public:
  inline CoalesceExpr() : CoalesceExpr(nullptr) {}
  virtual ~CoalesceExpr();

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

  inline CoalesceExpr& operator=(const CoalesceExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline CoalesceExpr& operator=(CoalesceExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CoalesceExpr& default_instance();

  static inline const CoalesceExpr* internal_default_instance() {
    return reinterpret_cast<const CoalesceExpr*>(
               &_CoalesceExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    45;

  friend void swap(CoalesceExpr& a, CoalesceExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(CoalesceExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CoalesceExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CoalesceExpr* New() const final {
    return CreateMaybeMessage<CoalesceExpr>(nullptr);
  }

  CoalesceExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CoalesceExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CoalesceExpr& from);
  void MergeFrom(const CoalesceExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CoalesceExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CoalesceExpr";
  }
  protected:
  explicit CoalesceExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 4,
    kXprFieldNumber = 1,
    kCoalescetypeFieldNumber = 2,
    kCoalescecollidFieldNumber = 3,
    kLocationFieldNumber = 5,
  };
  // repeated .pg_query.Node args = 4 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 coalescetype = 2 [json_name = "coalescetype"];
  void clear_coalescetype();
  ::PROTOBUF_NAMESPACE_ID::uint32 coalescetype() const;
  void set_coalescetype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_coalescetype() const;
  void _internal_set_coalescetype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 coalescecollid = 3 [json_name = "coalescecollid"];
  void clear_coalescecollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 coalescecollid() const;
  void set_coalescecollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_coalescecollid() const;
  void _internal_set_coalescecollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CoalesceExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 coalescetype_;
  ::PROTOBUF_NAMESPACE_ID::uint32 coalescecollid_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class MinMaxExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.MinMaxExpr) */ {
 public:
  inline MinMaxExpr() : MinMaxExpr(nullptr) {}
  virtual ~MinMaxExpr();

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

  inline MinMaxExpr& operator=(const MinMaxExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline MinMaxExpr& operator=(MinMaxExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MinMaxExpr& default_instance();

  static inline const MinMaxExpr* internal_default_instance() {
    return reinterpret_cast<const MinMaxExpr*>(
               &_MinMaxExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    46;

  friend void swap(MinMaxExpr& a, MinMaxExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(MinMaxExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MinMaxExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline MinMaxExpr* New() const final {
    return CreateMaybeMessage<MinMaxExpr>(nullptr);
  }

  MinMaxExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MinMaxExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MinMaxExpr& from);
  void MergeFrom(const MinMaxExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MinMaxExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.MinMaxExpr";
  }
  protected:
  explicit MinMaxExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 6,
    kXprFieldNumber = 1,
    kMinmaxtypeFieldNumber = 2,
    kMinmaxcollidFieldNumber = 3,
    kInputcollidFieldNumber = 4,
    kOpFieldNumber = 5,
    kLocationFieldNumber = 7,
  };
  // repeated .pg_query.Node args = 6 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 minmaxtype = 2 [json_name = "minmaxtype"];
  void clear_minmaxtype();
  ::PROTOBUF_NAMESPACE_ID::uint32 minmaxtype() const;
  void set_minmaxtype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_minmaxtype() const;
  void _internal_set_minmaxtype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 minmaxcollid = 3 [json_name = "minmaxcollid"];
  void clear_minmaxcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 minmaxcollid() const;
  void set_minmaxcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_minmaxcollid() const;
  void _internal_set_minmaxcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 inputcollid = 4 [json_name = "inputcollid"];
  void clear_inputcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid() const;
  void set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_inputcollid() const;
  void _internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .pg_query.MinMaxOp op = 5 [json_name = "op"];
  void clear_op();
  ::pg_query::MinMaxOp op() const;
  void set_op(::pg_query::MinMaxOp value);
  private:
  ::pg_query::MinMaxOp _internal_op() const;
  void _internal_set_op(::pg_query::MinMaxOp value);
  public:

  // int32 location = 7 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.MinMaxExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 minmaxtype_;
  ::PROTOBUF_NAMESPACE_ID::uint32 minmaxcollid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 inputcollid_;
  int op_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class SQLValueFunction PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SQLValueFunction) */ {
 public:
  inline SQLValueFunction() : SQLValueFunction(nullptr) {}
  virtual ~SQLValueFunction();

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

  inline SQLValueFunction& operator=(const SQLValueFunction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SQLValueFunction& operator=(SQLValueFunction&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SQLValueFunction& default_instance();

  static inline const SQLValueFunction* internal_default_instance() {
    return reinterpret_cast<const SQLValueFunction*>(
               &_SQLValueFunction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    47;

  friend void swap(SQLValueFunction& a, SQLValueFunction& b) {
    a.Swap(&b);
  }
  inline void Swap(SQLValueFunction* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SQLValueFunction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SQLValueFunction* New() const final {
    return CreateMaybeMessage<SQLValueFunction>(nullptr);
  }

  SQLValueFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SQLValueFunction>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SQLValueFunction& from);
  void MergeFrom(const SQLValueFunction& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SQLValueFunction* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.SQLValueFunction";
  }
  protected:
  explicit SQLValueFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kOpFieldNumber = 2,
    kTypeFieldNumber = 3,
    kTypmodFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.SQLValueFunctionOp op = 2 [json_name = "op"];
  void clear_op();
  ::pg_query::SQLValueFunctionOp op() const;
  void set_op(::pg_query::SQLValueFunctionOp value);
  private:
  ::pg_query::SQLValueFunctionOp _internal_op() const;
  void _internal_set_op(::pg_query::SQLValueFunctionOp value);
  public:

  // uint32 type = 3 [json_name = "type"];
  void clear_type();
  ::PROTOBUF_NAMESPACE_ID::uint32 type() const;
  void set_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type() const;
  void _internal_set_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 typmod = 4 [json_name = "typmod"];
  void clear_typmod();
  ::PROTOBUF_NAMESPACE_ID::int32 typmod() const;
  void set_typmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_typmod() const;
  void _internal_set_typmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.SQLValueFunction)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  int op_;
  ::PROTOBUF_NAMESPACE_ID::uint32 type_;
  ::PROTOBUF_NAMESPACE_ID::int32 typmod_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class XmlExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.XmlExpr) */ {
 public:
  inline XmlExpr() : XmlExpr(nullptr) {}
  virtual ~XmlExpr();

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

  inline XmlExpr& operator=(const XmlExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline XmlExpr& operator=(XmlExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const XmlExpr& default_instance();

  static inline const XmlExpr* internal_default_instance() {
    return reinterpret_cast<const XmlExpr*>(
               &_XmlExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    48;

  friend void swap(XmlExpr& a, XmlExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(XmlExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(XmlExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline XmlExpr* New() const final {
    return CreateMaybeMessage<XmlExpr>(nullptr);
  }

  XmlExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<XmlExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const XmlExpr& from);
  void MergeFrom(const XmlExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(XmlExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.XmlExpr";
  }
  protected:
  explicit XmlExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNamedArgsFieldNumber = 4,
    kArgNamesFieldNumber = 5,
    kArgsFieldNumber = 6,
    kNameFieldNumber = 3,
    kXprFieldNumber = 1,
    kOpFieldNumber = 2,
    kXmloptionFieldNumber = 7,
    kTypeFieldNumber = 8,
    kTypmodFieldNumber = 9,
    kLocationFieldNumber = 10,
  };
  // repeated .pg_query.Node named_args = 4 [json_name = "named_args"];
  int named_args_size() const;
  private:
  int _internal_named_args_size() const;
  public:
  void clear_named_args();
  ::pg_query::Node* mutable_named_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_named_args();
  private:
  const ::pg_query::Node& _internal_named_args(int index) const;
  ::pg_query::Node* _internal_add_named_args();
  public:
  const ::pg_query::Node& named_args(int index) const;
  ::pg_query::Node* add_named_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      named_args() const;

  // repeated .pg_query.Node arg_names = 5 [json_name = "arg_names"];
  int arg_names_size() const;
  private:
  int _internal_arg_names_size() const;
  public:
  void clear_arg_names();
  ::pg_query::Node* mutable_arg_names(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_arg_names();
  private:
  const ::pg_query::Node& _internal_arg_names(int index) const;
  ::pg_query::Node* _internal_add_arg_names();
  public:
  const ::pg_query::Node& arg_names(int index) const;
  ::pg_query::Node* add_arg_names();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      arg_names() const;

  // repeated .pg_query.Node args = 6 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // string name = 3 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.XmlExprOp op = 2 [json_name = "op"];
  void clear_op();
  ::pg_query::XmlExprOp op() const;
  void set_op(::pg_query::XmlExprOp value);
  private:
  ::pg_query::XmlExprOp _internal_op() const;
  void _internal_set_op(::pg_query::XmlExprOp value);
  public:

  // .pg_query.XmlOptionType xmloption = 7 [json_name = "xmloption"];
  void clear_xmloption();
  ::pg_query::XmlOptionType xmloption() const;
  void set_xmloption(::pg_query::XmlOptionType value);
  private:
  ::pg_query::XmlOptionType _internal_xmloption() const;
  void _internal_set_xmloption(::pg_query::XmlOptionType value);
  public:

  // uint32 type = 8 [json_name = "type"];
  void clear_type();
  ::PROTOBUF_NAMESPACE_ID::uint32 type() const;
  void set_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type() const;
  void _internal_set_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 typmod = 9 [json_name = "typmod"];
  void clear_typmod();
  ::PROTOBUF_NAMESPACE_ID::int32 typmod() const;
  void set_typmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_typmod() const;
  void _internal_set_typmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 location = 10 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.XmlExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > named_args_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > arg_names_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::pg_query::Node* xpr_;
  int op_;
  int xmloption_;
  ::PROTOBUF_NAMESPACE_ID::uint32 type_;
  ::PROTOBUF_NAMESPACE_ID::int32 typmod_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class NullTest PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.NullTest) */ {
 public:
  inline NullTest() : NullTest(nullptr) {}
  virtual ~NullTest();

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

  inline NullTest& operator=(const NullTest& from) {
    CopyFrom(from);
    return *this;
  }
  inline NullTest& operator=(NullTest&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const NullTest& default_instance();

  static inline const NullTest* internal_default_instance() {
    return reinterpret_cast<const NullTest*>(
               &_NullTest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    49;

  friend void swap(NullTest& a, NullTest& b) {
    a.Swap(&b);
  }
  inline void Swap(NullTest* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NullTest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline NullTest* New() const final {
    return CreateMaybeMessage<NullTest>(nullptr);
  }

  NullTest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<NullTest>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const NullTest& from);
  void MergeFrom(const NullTest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NullTest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.NullTest";
  }
  protected:
  explicit NullTest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kArgFieldNumber = 2,
    kNulltesttypeFieldNumber = 3,
    kArgisrowFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // .pg_query.NullTestType nulltesttype = 3 [json_name = "nulltesttype"];
  void clear_nulltesttype();
  ::pg_query::NullTestType nulltesttype() const;
  void set_nulltesttype(::pg_query::NullTestType value);
  private:
  ::pg_query::NullTestType _internal_nulltesttype() const;
  void _internal_set_nulltesttype(::pg_query::NullTestType value);
  public:

  // bool argisrow = 4 [json_name = "argisrow"];
  void clear_argisrow();
  bool argisrow() const;
  void set_argisrow(bool value);
  private:
  bool _internal_argisrow() const;
  void _internal_set_argisrow(bool value);
  public:

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.NullTest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* arg_;
  int nulltesttype_;
  bool argisrow_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class BooleanTest PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.BooleanTest) */ {
 public:
  inline BooleanTest() : BooleanTest(nullptr) {}
  virtual ~BooleanTest();

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

  inline BooleanTest& operator=(const BooleanTest& from) {
    CopyFrom(from);
    return *this;
  }
  inline BooleanTest& operator=(BooleanTest&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const BooleanTest& default_instance();

  static inline const BooleanTest* internal_default_instance() {
    return reinterpret_cast<const BooleanTest*>(
               &_BooleanTest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    50;

  friend void swap(BooleanTest& a, BooleanTest& b) {
    a.Swap(&b);
  }
  inline void Swap(BooleanTest* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BooleanTest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline BooleanTest* New() const final {
    return CreateMaybeMessage<BooleanTest>(nullptr);
  }

  BooleanTest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BooleanTest>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BooleanTest& from);
  void MergeFrom(const BooleanTest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BooleanTest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.BooleanTest";
  }
  protected:
  explicit BooleanTest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kArgFieldNumber = 2,
    kBooltesttypeFieldNumber = 3,
    kLocationFieldNumber = 4,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // .pg_query.BoolTestType booltesttype = 3 [json_name = "booltesttype"];
  void clear_booltesttype();
  ::pg_query::BoolTestType booltesttype() const;
  void set_booltesttype(::pg_query::BoolTestType value);
  private:
  ::pg_query::BoolTestType _internal_booltesttype() const;
  void _internal_set_booltesttype(::pg_query::BoolTestType value);
  public:

  // int32 location = 4 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.BooleanTest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* arg_;
  int booltesttype_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CoerceToDomain PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CoerceToDomain) */ {
 public:
  inline CoerceToDomain() : CoerceToDomain(nullptr) {}
  virtual ~CoerceToDomain();

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

  inline CoerceToDomain& operator=(const CoerceToDomain& from) {
    CopyFrom(from);
    return *this;
  }
  inline CoerceToDomain& operator=(CoerceToDomain&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CoerceToDomain& default_instance();

  static inline const CoerceToDomain* internal_default_instance() {
    return reinterpret_cast<const CoerceToDomain*>(
               &_CoerceToDomain_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    51;

  friend void swap(CoerceToDomain& a, CoerceToDomain& b) {
    a.Swap(&b);
  }
  inline void Swap(CoerceToDomain* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CoerceToDomain* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CoerceToDomain* New() const final {
    return CreateMaybeMessage<CoerceToDomain>(nullptr);
  }

  CoerceToDomain* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CoerceToDomain>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CoerceToDomain& from);
  void MergeFrom(const CoerceToDomain& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CoerceToDomain* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CoerceToDomain";
  }
  protected:
  explicit CoerceToDomain(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kArgFieldNumber = 2,
    kResulttypeFieldNumber = 3,
    kResulttypmodFieldNumber = 4,
    kResultcollidFieldNumber = 5,
    kCoercionformatFieldNumber = 6,
    kLocationFieldNumber = 7,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // uint32 resulttype = 3 [json_name = "resulttype"];
  void clear_resulttype();
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype() const;
  void set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resulttype() const;
  void _internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 resulttypmod = 4 [json_name = "resulttypmod"];
  void clear_resulttypmod();
  ::PROTOBUF_NAMESPACE_ID::int32 resulttypmod() const;
  void set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_resulttypmod() const;
  void _internal_set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 resultcollid = 5 [json_name = "resultcollid"];
  void clear_resultcollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 resultcollid() const;
  void set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resultcollid() const;
  void _internal_set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .pg_query.CoercionForm coercionformat = 6 [json_name = "coercionformat"];
  void clear_coercionformat();
  ::pg_query::CoercionForm coercionformat() const;
  void set_coercionformat(::pg_query::CoercionForm value);
  private:
  ::pg_query::CoercionForm _internal_coercionformat() const;
  void _internal_set_coercionformat(::pg_query::CoercionForm value);
  public:

  // int32 location = 7 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CoerceToDomain)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* arg_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resulttype_;
  ::PROTOBUF_NAMESPACE_ID::int32 resulttypmod_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resultcollid_;
  int coercionformat_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CoerceToDomainValue PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CoerceToDomainValue) */ {
 public:
  inline CoerceToDomainValue() : CoerceToDomainValue(nullptr) {}
  virtual ~CoerceToDomainValue();

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

  inline CoerceToDomainValue& operator=(const CoerceToDomainValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline CoerceToDomainValue& operator=(CoerceToDomainValue&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CoerceToDomainValue& default_instance();

  static inline const CoerceToDomainValue* internal_default_instance() {
    return reinterpret_cast<const CoerceToDomainValue*>(
               &_CoerceToDomainValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    52;

  friend void swap(CoerceToDomainValue& a, CoerceToDomainValue& b) {
    a.Swap(&b);
  }
  inline void Swap(CoerceToDomainValue* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CoerceToDomainValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CoerceToDomainValue* New() const final {
    return CreateMaybeMessage<CoerceToDomainValue>(nullptr);
  }

  CoerceToDomainValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CoerceToDomainValue>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CoerceToDomainValue& from);
  void MergeFrom(const CoerceToDomainValue& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CoerceToDomainValue* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CoerceToDomainValue";
  }
  protected:
  explicit CoerceToDomainValue(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kTypeIdFieldNumber = 2,
    kTypeModFieldNumber = 3,
    kCollationFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 type_id = 2 [json_name = "typeId"];
  void clear_type_id();
  ::PROTOBUF_NAMESPACE_ID::uint32 type_id() const;
  void set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_id() const;
  void _internal_set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 type_mod = 3 [json_name = "typeMod"];
  void clear_type_mod();
  ::PROTOBUF_NAMESPACE_ID::int32 type_mod() const;
  void set_type_mod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_type_mod() const;
  void _internal_set_type_mod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 collation = 4 [json_name = "collation"];
  void clear_collation();
  ::PROTOBUF_NAMESPACE_ID::uint32 collation() const;
  void set_collation(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_collation() const;
  void _internal_set_collation(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CoerceToDomainValue)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 type_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 type_mod_;
  ::PROTOBUF_NAMESPACE_ID::uint32 collation_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class SetToDefault PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SetToDefault) */ {
 public:
  inline SetToDefault() : SetToDefault(nullptr) {}
  virtual ~SetToDefault();

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

  inline SetToDefault& operator=(const SetToDefault& from) {
    CopyFrom(from);
    return *this;
  }
  inline SetToDefault& operator=(SetToDefault&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SetToDefault& default_instance();

  static inline const SetToDefault* internal_default_instance() {
    return reinterpret_cast<const SetToDefault*>(
               &_SetToDefault_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    53;

  friend void swap(SetToDefault& a, SetToDefault& b) {
    a.Swap(&b);
  }
  inline void Swap(SetToDefault* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SetToDefault* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SetToDefault* New() const final {
    return CreateMaybeMessage<SetToDefault>(nullptr);
  }

  SetToDefault* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SetToDefault>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SetToDefault& from);
  void MergeFrom(const SetToDefault& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SetToDefault* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.SetToDefault";
  }
  protected:
  explicit SetToDefault(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kTypeIdFieldNumber = 2,
    kTypeModFieldNumber = 3,
    kCollationFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 type_id = 2 [json_name = "typeId"];
  void clear_type_id();
  ::PROTOBUF_NAMESPACE_ID::uint32 type_id() const;
  void set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_id() const;
  void _internal_set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 type_mod = 3 [json_name = "typeMod"];
  void clear_type_mod();
  ::PROTOBUF_NAMESPACE_ID::int32 type_mod() const;
  void set_type_mod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_type_mod() const;
  void _internal_set_type_mod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 collation = 4 [json_name = "collation"];
  void clear_collation();
  ::PROTOBUF_NAMESPACE_ID::uint32 collation() const;
  void set_collation(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_collation() const;
  void _internal_set_collation(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.SetToDefault)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 type_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 type_mod_;
  ::PROTOBUF_NAMESPACE_ID::uint32 collation_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CurrentOfExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CurrentOfExpr) */ {
 public:
  inline CurrentOfExpr() : CurrentOfExpr(nullptr) {}
  virtual ~CurrentOfExpr();

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

  inline CurrentOfExpr& operator=(const CurrentOfExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline CurrentOfExpr& operator=(CurrentOfExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CurrentOfExpr& default_instance();

  static inline const CurrentOfExpr* internal_default_instance() {
    return reinterpret_cast<const CurrentOfExpr*>(
               &_CurrentOfExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    54;

  friend void swap(CurrentOfExpr& a, CurrentOfExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(CurrentOfExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CurrentOfExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CurrentOfExpr* New() const final {
    return CreateMaybeMessage<CurrentOfExpr>(nullptr);
  }

  CurrentOfExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CurrentOfExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CurrentOfExpr& from);
  void MergeFrom(const CurrentOfExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CurrentOfExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CurrentOfExpr";
  }
  protected:
  explicit CurrentOfExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCursorNameFieldNumber = 3,
    kXprFieldNumber = 1,
    kCvarnoFieldNumber = 2,
    kCursorParamFieldNumber = 4,
  };
  // string cursor_name = 3 [json_name = "cursor_name"];
  void clear_cursor_name();
  const std::string& cursor_name() const;
  void set_cursor_name(const std::string& value);
  void set_cursor_name(std::string&& value);
  void set_cursor_name(const char* value);
  void set_cursor_name(const char* value, size_t size);
  std::string* mutable_cursor_name();
  std::string* release_cursor_name();
  void set_allocated_cursor_name(std::string* cursor_name);
  private:
  const std::string& _internal_cursor_name() const;
  void _internal_set_cursor_name(const std::string& value);
  std::string* _internal_mutable_cursor_name();
  public:

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 cvarno = 2 [json_name = "cvarno"];
  void clear_cvarno();
  ::PROTOBUF_NAMESPACE_ID::uint32 cvarno() const;
  void set_cvarno(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_cvarno() const;
  void _internal_set_cvarno(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 cursor_param = 4 [json_name = "cursor_param"];
  void clear_cursor_param();
  ::PROTOBUF_NAMESPACE_ID::int32 cursor_param() const;
  void set_cursor_param(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cursor_param() const;
  void _internal_set_cursor_param(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CurrentOfExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cursor_name_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 cvarno_;
  ::PROTOBUF_NAMESPACE_ID::int32 cursor_param_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class NextValueExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.NextValueExpr) */ {
 public:
  inline NextValueExpr() : NextValueExpr(nullptr) {}
  virtual ~NextValueExpr();

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

  inline NextValueExpr& operator=(const NextValueExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline NextValueExpr& operator=(NextValueExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const NextValueExpr& default_instance();

  static inline const NextValueExpr* internal_default_instance() {
    return reinterpret_cast<const NextValueExpr*>(
               &_NextValueExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    55;

  friend void swap(NextValueExpr& a, NextValueExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(NextValueExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NextValueExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline NextValueExpr* New() const final {
    return CreateMaybeMessage<NextValueExpr>(nullptr);
  }

  NextValueExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<NextValueExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const NextValueExpr& from);
  void MergeFrom(const NextValueExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NextValueExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.NextValueExpr";
  }
  protected:
  explicit NextValueExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kSeqidFieldNumber = 2,
    kTypeIdFieldNumber = 3,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // uint32 seqid = 2 [json_name = "seqid"];
  void clear_seqid();
  ::PROTOBUF_NAMESPACE_ID::uint32 seqid() const;
  void set_seqid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_seqid() const;
  void _internal_set_seqid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 type_id = 3 [json_name = "typeId"];
  void clear_type_id();
  ::PROTOBUF_NAMESPACE_ID::uint32 type_id() const;
  void set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_id() const;
  void _internal_set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.NextValueExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 seqid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 type_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class InferenceElem PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.InferenceElem) */ {
 public:
  inline InferenceElem() : InferenceElem(nullptr) {}
  virtual ~InferenceElem();

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

  inline InferenceElem& operator=(const InferenceElem& from) {
    CopyFrom(from);
    return *this;
  }
  inline InferenceElem& operator=(InferenceElem&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const InferenceElem& default_instance();

  static inline const InferenceElem* internal_default_instance() {
    return reinterpret_cast<const InferenceElem*>(
               &_InferenceElem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    56;

  friend void swap(InferenceElem& a, InferenceElem& b) {
    a.Swap(&b);
  }
  inline void Swap(InferenceElem* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InferenceElem* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline InferenceElem* New() const final {
    return CreateMaybeMessage<InferenceElem>(nullptr);
  }

  InferenceElem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<InferenceElem>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const InferenceElem& from);
  void MergeFrom(const InferenceElem& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InferenceElem* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.InferenceElem";
  }
  protected:
  explicit InferenceElem(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXprFieldNumber = 1,
    kExprFieldNumber = 2,
    kInfercollidFieldNumber = 3,
    kInferopclassFieldNumber = 4,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node expr = 2 [json_name = "expr"];
  bool has_expr() const;
  private:
  bool _internal_has_expr() const;
  public:
  void clear_expr();
  const ::pg_query::Node& expr() const;
  ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* expr);
  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();
  public:
  void unsafe_arena_set_allocated_expr(
      ::pg_query::Node* expr);
  ::pg_query::Node* unsafe_arena_release_expr();

  // uint32 infercollid = 3 [json_name = "infercollid"];
  void clear_infercollid();
  ::PROTOBUF_NAMESPACE_ID::uint32 infercollid() const;
  void set_infercollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_infercollid() const;
  void _internal_set_infercollid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 inferopclass = 4 [json_name = "inferopclass"];
  void clear_inferopclass();
  ::PROTOBUF_NAMESPACE_ID::uint32 inferopclass() const;
  void set_inferopclass(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_inferopclass() const;
  void _internal_set_inferopclass(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.InferenceElem)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* expr_;
  ::PROTOBUF_NAMESPACE_ID::uint32 infercollid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 inferopclass_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class TargetEntry PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TargetEntry) */ {
 public:
  inline TargetEntry() : TargetEntry(nullptr) {}
  virtual ~TargetEntry();

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

  inline TargetEntry& operator=(const TargetEntry& from) {
    CopyFrom(from);
    return *this;
  }
  inline TargetEntry& operator=(TargetEntry&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TargetEntry& default_instance();

  static inline const TargetEntry* internal_default_instance() {
    return reinterpret_cast<const TargetEntry*>(
               &_TargetEntry_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    57;

  friend void swap(TargetEntry& a, TargetEntry& b) {
    a.Swap(&b);
  }
  inline void Swap(TargetEntry* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TargetEntry* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline TargetEntry* New() const final {
    return CreateMaybeMessage<TargetEntry>(nullptr);
  }

  TargetEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TargetEntry>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TargetEntry& from);
  void MergeFrom(const TargetEntry& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TargetEntry* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.TargetEntry";
  }
  protected:
  explicit TargetEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kResnameFieldNumber = 4,
    kXprFieldNumber = 1,
    kExprFieldNumber = 2,
    kResnoFieldNumber = 3,
    kRessortgrouprefFieldNumber = 5,
    kResorigtblFieldNumber = 6,
    kResorigcolFieldNumber = 7,
    kResjunkFieldNumber = 8,
  };
  // string resname = 4 [json_name = "resname"];
  void clear_resname();
  const std::string& resname() const;
  void set_resname(const std::string& value);
  void set_resname(std::string&& value);
  void set_resname(const char* value);
  void set_resname(const char* value, size_t size);
  std::string* mutable_resname();
  std::string* release_resname();
  void set_allocated_resname(std::string* resname);
  private:
  const std::string& _internal_resname() const;
  void _internal_set_resname(const std::string& value);
  std::string* _internal_mutable_resname();
  public:

  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  private:
  bool _internal_has_xpr() const;
  public:
  void clear_xpr();
  const ::pg_query::Node& xpr() const;
  ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* xpr);
  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();
  public:
  void unsafe_arena_set_allocated_xpr(
      ::pg_query::Node* xpr);
  ::pg_query::Node* unsafe_arena_release_xpr();

  // .pg_query.Node expr = 2 [json_name = "expr"];
  bool has_expr() const;
  private:
  bool _internal_has_expr() const;
  public:
  void clear_expr();
  const ::pg_query::Node& expr() const;
  ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* expr);
  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();
  public:
  void unsafe_arena_set_allocated_expr(
      ::pg_query::Node* expr);
  ::pg_query::Node* unsafe_arena_release_expr();

  // int32 resno = 3 [json_name = "resno"];
  void clear_resno();
  ::PROTOBUF_NAMESPACE_ID::int32 resno() const;
  void set_resno(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_resno() const;
  void _internal_set_resno(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 ressortgroupref = 5 [json_name = "ressortgroupref"];
  void clear_ressortgroupref();
  ::PROTOBUF_NAMESPACE_ID::uint32 ressortgroupref() const;
  void set_ressortgroupref(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_ressortgroupref() const;
  void _internal_set_ressortgroupref(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 resorigtbl = 6 [json_name = "resorigtbl"];
  void clear_resorigtbl();
  ::PROTOBUF_NAMESPACE_ID::uint32 resorigtbl() const;
  void set_resorigtbl(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resorigtbl() const;
  void _internal_set_resorigtbl(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 resorigcol = 7 [json_name = "resorigcol"];
  void clear_resorigcol();
  ::PROTOBUF_NAMESPACE_ID::int32 resorigcol() const;
  void set_resorigcol(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_resorigcol() const;
  void _internal_set_resorigcol(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool resjunk = 8 [json_name = "resjunk"];
  void clear_resjunk();
  bool resjunk() const;
  void set_resjunk(bool value);
  private:
  bool _internal_resjunk() const;
  void _internal_set_resjunk(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.TargetEntry)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr resname_;
  ::pg_query::Node* xpr_;
  ::pg_query::Node* expr_;
  ::PROTOBUF_NAMESPACE_ID::int32 resno_;
  ::PROTOBUF_NAMESPACE_ID::uint32 ressortgroupref_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resorigtbl_;
  ::PROTOBUF_NAMESPACE_ID::int32 resorigcol_;
  bool resjunk_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RangeTblRef PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTblRef) */ {
 public:
  inline RangeTblRef() : RangeTblRef(nullptr) {}
  virtual ~RangeTblRef();

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

  inline RangeTblRef& operator=(const RangeTblRef& from) {
    CopyFrom(from);
    return *this;
  }
  inline RangeTblRef& operator=(RangeTblRef&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RangeTblRef& default_instance();

  static inline const RangeTblRef* internal_default_instance() {
    return reinterpret_cast<const RangeTblRef*>(
               &_RangeTblRef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    58;

  friend void swap(RangeTblRef& a, RangeTblRef& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeTblRef* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeTblRef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline RangeTblRef* New() const final {
    return CreateMaybeMessage<RangeTblRef>(nullptr);
  }

  RangeTblRef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RangeTblRef>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RangeTblRef& from);
  void MergeFrom(const RangeTblRef& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RangeTblRef* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RangeTblRef";
  }
  protected:
  explicit RangeTblRef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRtindexFieldNumber = 1,
  };
  // int32 rtindex = 1 [json_name = "rtindex"];
  void clear_rtindex();
  ::PROTOBUF_NAMESPACE_ID::int32 rtindex() const;
  void set_rtindex(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_rtindex() const;
  void _internal_set_rtindex(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RangeTblRef)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int32 rtindex_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class JoinExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.JoinExpr) */ {
 public:
  inline JoinExpr() : JoinExpr(nullptr) {}
  virtual ~JoinExpr();

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

  inline JoinExpr& operator=(const JoinExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline JoinExpr& operator=(JoinExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const JoinExpr& default_instance();

  static inline const JoinExpr* internal_default_instance() {
    return reinterpret_cast<const JoinExpr*>(
               &_JoinExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    59;

  friend void swap(JoinExpr& a, JoinExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(JoinExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(JoinExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline JoinExpr* New() const final {
    return CreateMaybeMessage<JoinExpr>(nullptr);
  }

  JoinExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<JoinExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const JoinExpr& from);
  void MergeFrom(const JoinExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(JoinExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.JoinExpr";
  }
  protected:
  explicit JoinExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kUsingClauseFieldNumber = 5,
    kLargFieldNumber = 3,
    kRargFieldNumber = 4,
    kQualsFieldNumber = 6,
    kAliasFieldNumber = 7,
    kJointypeFieldNumber = 1,
    kIsNaturalFieldNumber = 2,
    kRtindexFieldNumber = 8,
  };
  // repeated .pg_query.Node using_clause = 5 [json_name = "usingClause"];
  int using_clause_size() const;
  private:
  int _internal_using_clause_size() const;
  public:
  void clear_using_clause();
  ::pg_query::Node* mutable_using_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_using_clause();
  private:
  const ::pg_query::Node& _internal_using_clause(int index) const;
  ::pg_query::Node* _internal_add_using_clause();
  public:
  const ::pg_query::Node& using_clause(int index) const;
  ::pg_query::Node* add_using_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      using_clause() const;

  // .pg_query.Node larg = 3 [json_name = "larg"];
  bool has_larg() const;
  private:
  bool _internal_has_larg() const;
  public:
  void clear_larg();
  const ::pg_query::Node& larg() const;
  ::pg_query::Node* release_larg();
  ::pg_query::Node* mutable_larg();
  void set_allocated_larg(::pg_query::Node* larg);
  private:
  const ::pg_query::Node& _internal_larg() const;
  ::pg_query::Node* _internal_mutable_larg();
  public:
  void unsafe_arena_set_allocated_larg(
      ::pg_query::Node* larg);
  ::pg_query::Node* unsafe_arena_release_larg();

  // .pg_query.Node rarg = 4 [json_name = "rarg"];
  bool has_rarg() const;
  private:
  bool _internal_has_rarg() const;
  public:
  void clear_rarg();
  const ::pg_query::Node& rarg() const;
  ::pg_query::Node* release_rarg();
  ::pg_query::Node* mutable_rarg();
  void set_allocated_rarg(::pg_query::Node* rarg);
  private:
  const ::pg_query::Node& _internal_rarg() const;
  ::pg_query::Node* _internal_mutable_rarg();
  public:
  void unsafe_arena_set_allocated_rarg(
      ::pg_query::Node* rarg);
  ::pg_query::Node* unsafe_arena_release_rarg();

  // .pg_query.Node quals = 6 [json_name = "quals"];
  bool has_quals() const;
  private:
  bool _internal_has_quals() const;
  public:
  void clear_quals();
  const ::pg_query::Node& quals() const;
  ::pg_query::Node* release_quals();
  ::pg_query::Node* mutable_quals();
  void set_allocated_quals(::pg_query::Node* quals);
  private:
  const ::pg_query::Node& _internal_quals() const;
  ::pg_query::Node* _internal_mutable_quals();
  public:
  void unsafe_arena_set_allocated_quals(
      ::pg_query::Node* quals);
  ::pg_query::Node* unsafe_arena_release_quals();

  // .pg_query.Alias alias = 7 [json_name = "alias"];
  bool has_alias() const;
  private:
  bool _internal_has_alias() const;
  public:
  void clear_alias();
  const ::pg_query::Alias& alias() const;
  ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* alias);
  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();
  public:
  void unsafe_arena_set_allocated_alias(
      ::pg_query::Alias* alias);
  ::pg_query::Alias* unsafe_arena_release_alias();

  // .pg_query.JoinType jointype = 1 [json_name = "jointype"];
  void clear_jointype();
  ::pg_query::JoinType jointype() const;
  void set_jointype(::pg_query::JoinType value);
  private:
  ::pg_query::JoinType _internal_jointype() const;
  void _internal_set_jointype(::pg_query::JoinType value);
  public:

  // bool is_natural = 2 [json_name = "isNatural"];
  void clear_is_natural();
  bool is_natural() const;
  void set_is_natural(bool value);
  private:
  bool _internal_is_natural() const;
  void _internal_set_is_natural(bool value);
  public:

  // int32 rtindex = 8 [json_name = "rtindex"];
  void clear_rtindex();
  ::PROTOBUF_NAMESPACE_ID::int32 rtindex() const;
  void set_rtindex(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_rtindex() const;
  void _internal_set_rtindex(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.JoinExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > using_clause_;
  ::pg_query::Node* larg_;
  ::pg_query::Node* rarg_;
  ::pg_query::Node* quals_;
  ::pg_query::Alias* alias_;
  int jointype_;
  bool is_natural_;
  ::PROTOBUF_NAMESPACE_ID::int32 rtindex_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class FromExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FromExpr) */ {
 public:
  inline FromExpr() : FromExpr(nullptr) {}
  virtual ~FromExpr();

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

  inline FromExpr& operator=(const FromExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline FromExpr& operator=(FromExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const FromExpr& default_instance();

  static inline const FromExpr* internal_default_instance() {
    return reinterpret_cast<const FromExpr*>(
               &_FromExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    60;

  friend void swap(FromExpr& a, FromExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(FromExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FromExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline FromExpr* New() const final {
    return CreateMaybeMessage<FromExpr>(nullptr);
  }

  FromExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FromExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const FromExpr& from);
  void MergeFrom(const FromExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FromExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.FromExpr";
  }
  protected:
  explicit FromExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kFromlistFieldNumber = 1,
    kQualsFieldNumber = 2,
  };
  // repeated .pg_query.Node fromlist = 1 [json_name = "fromlist"];
  int fromlist_size() const;
  private:
  int _internal_fromlist_size() const;
  public:
  void clear_fromlist();
  ::pg_query::Node* mutable_fromlist(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_fromlist();
  private:
  const ::pg_query::Node& _internal_fromlist(int index) const;
  ::pg_query::Node* _internal_add_fromlist();
  public:
  const ::pg_query::Node& fromlist(int index) const;
  ::pg_query::Node* add_fromlist();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      fromlist() const;

  // .pg_query.Node quals = 2 [json_name = "quals"];
  bool has_quals() const;
  private:
  bool _internal_has_quals() const;
  public:
  void clear_quals();
  const ::pg_query::Node& quals() const;
  ::pg_query::Node* release_quals();
  ::pg_query::Node* mutable_quals();
  void set_allocated_quals(::pg_query::Node* quals);
  private:
  const ::pg_query::Node& _internal_quals() const;
  ::pg_query::Node* _internal_mutable_quals();
  public:
  void unsafe_arena_set_allocated_quals(
      ::pg_query::Node* quals);
  ::pg_query::Node* unsafe_arena_release_quals();

  // @@protoc_insertion_point(class_scope:pg_query.FromExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > fromlist_;
  ::pg_query::Node* quals_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class OnConflictExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.OnConflictExpr) */ {
 public:
  inline OnConflictExpr() : OnConflictExpr(nullptr) {}
  virtual ~OnConflictExpr();

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

  inline OnConflictExpr& operator=(const OnConflictExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline OnConflictExpr& operator=(OnConflictExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const OnConflictExpr& default_instance();

  static inline const OnConflictExpr* internal_default_instance() {
    return reinterpret_cast<const OnConflictExpr*>(
               &_OnConflictExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    61;

  friend void swap(OnConflictExpr& a, OnConflictExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(OnConflictExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OnConflictExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline OnConflictExpr* New() const final {
    return CreateMaybeMessage<OnConflictExpr>(nullptr);
  }

  OnConflictExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<OnConflictExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const OnConflictExpr& from);
  void MergeFrom(const OnConflictExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OnConflictExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.OnConflictExpr";
  }
  protected:
  explicit OnConflictExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArbiterElemsFieldNumber = 2,
    kOnConflictSetFieldNumber = 5,
    kExclRelTlistFieldNumber = 8,
    kArbiterWhereFieldNumber = 3,
    kOnConflictWhereFieldNumber = 6,
    kActionFieldNumber = 1,
    kConstraintFieldNumber = 4,
    kExclRelIndexFieldNumber = 7,
  };
  // repeated .pg_query.Node arbiter_elems = 2 [json_name = "arbiterElems"];
  int arbiter_elems_size() const;
  private:
  int _internal_arbiter_elems_size() const;
  public:
  void clear_arbiter_elems();
  ::pg_query::Node* mutable_arbiter_elems(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_arbiter_elems();
  private:
  const ::pg_query::Node& _internal_arbiter_elems(int index) const;
  ::pg_query::Node* _internal_add_arbiter_elems();
  public:
  const ::pg_query::Node& arbiter_elems(int index) const;
  ::pg_query::Node* add_arbiter_elems();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      arbiter_elems() const;

  // repeated .pg_query.Node on_conflict_set = 5 [json_name = "onConflictSet"];
  int on_conflict_set_size() const;
  private:
  int _internal_on_conflict_set_size() const;
  public:
  void clear_on_conflict_set();
  ::pg_query::Node* mutable_on_conflict_set(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_on_conflict_set();
  private:
  const ::pg_query::Node& _internal_on_conflict_set(int index) const;
  ::pg_query::Node* _internal_add_on_conflict_set();
  public:
  const ::pg_query::Node& on_conflict_set(int index) const;
  ::pg_query::Node* add_on_conflict_set();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      on_conflict_set() const;

  // repeated .pg_query.Node excl_rel_tlist = 8 [json_name = "exclRelTlist"];
  int excl_rel_tlist_size() const;
  private:
  int _internal_excl_rel_tlist_size() const;
  public:
  void clear_excl_rel_tlist();
  ::pg_query::Node* mutable_excl_rel_tlist(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_excl_rel_tlist();
  private:
  const ::pg_query::Node& _internal_excl_rel_tlist(int index) const;
  ::pg_query::Node* _internal_add_excl_rel_tlist();
  public:
  const ::pg_query::Node& excl_rel_tlist(int index) const;
  ::pg_query::Node* add_excl_rel_tlist();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      excl_rel_tlist() const;

  // .pg_query.Node arbiter_where = 3 [json_name = "arbiterWhere"];
  bool has_arbiter_where() const;
  private:
  bool _internal_has_arbiter_where() const;
  public:
  void clear_arbiter_where();
  const ::pg_query::Node& arbiter_where() const;
  ::pg_query::Node* release_arbiter_where();
  ::pg_query::Node* mutable_arbiter_where();
  void set_allocated_arbiter_where(::pg_query::Node* arbiter_where);
  private:
  const ::pg_query::Node& _internal_arbiter_where() const;
  ::pg_query::Node* _internal_mutable_arbiter_where();
  public:
  void unsafe_arena_set_allocated_arbiter_where(
      ::pg_query::Node* arbiter_where);
  ::pg_query::Node* unsafe_arena_release_arbiter_where();

  // .pg_query.Node on_conflict_where = 6 [json_name = "onConflictWhere"];
  bool has_on_conflict_where() const;
  private:
  bool _internal_has_on_conflict_where() const;
  public:
  void clear_on_conflict_where();
  const ::pg_query::Node& on_conflict_where() const;
  ::pg_query::Node* release_on_conflict_where();
  ::pg_query::Node* mutable_on_conflict_where();
  void set_allocated_on_conflict_where(::pg_query::Node* on_conflict_where);
  private:
  const ::pg_query::Node& _internal_on_conflict_where() const;
  ::pg_query::Node* _internal_mutable_on_conflict_where();
  public:
  void unsafe_arena_set_allocated_on_conflict_where(
      ::pg_query::Node* on_conflict_where);
  ::pg_query::Node* unsafe_arena_release_on_conflict_where();

  // .pg_query.OnConflictAction action = 1 [json_name = "action"];
  void clear_action();
  ::pg_query::OnConflictAction action() const;
  void set_action(::pg_query::OnConflictAction value);
  private:
  ::pg_query::OnConflictAction _internal_action() const;
  void _internal_set_action(::pg_query::OnConflictAction value);
  public:

  // uint32 constraint = 4 [json_name = "constraint"];
  void clear_constraint();
  ::PROTOBUF_NAMESPACE_ID::uint32 constraint() const;
  void set_constraint(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_constraint() const;
  void _internal_set_constraint(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 excl_rel_index = 7 [json_name = "exclRelIndex"];
  void clear_excl_rel_index();
  ::PROTOBUF_NAMESPACE_ID::int32 excl_rel_index() const;
  void set_excl_rel_index(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_excl_rel_index() const;
  void _internal_set_excl_rel_index(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.OnConflictExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > arbiter_elems_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > on_conflict_set_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > excl_rel_tlist_;
  ::pg_query::Node* arbiter_where_;
  ::pg_query::Node* on_conflict_where_;
  int action_;
  ::PROTOBUF_NAMESPACE_ID::uint32 constraint_;
  ::PROTOBUF_NAMESPACE_ID::int32 excl_rel_index_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class IntoClause PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.IntoClause) */ {
 public:
  inline IntoClause() : IntoClause(nullptr) {}
  virtual ~IntoClause();

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

  inline IntoClause& operator=(const IntoClause& from) {
    CopyFrom(from);
    return *this;
  }
  inline IntoClause& operator=(IntoClause&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const IntoClause& default_instance();

  static inline const IntoClause* internal_default_instance() {
    return reinterpret_cast<const IntoClause*>(
               &_IntoClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    62;

  friend void swap(IntoClause& a, IntoClause& b) {
    a.Swap(&b);
  }
  inline void Swap(IntoClause* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IntoClause* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline IntoClause* New() const final {
    return CreateMaybeMessage<IntoClause>(nullptr);
  }

  IntoClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<IntoClause>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const IntoClause& from);
  void MergeFrom(const IntoClause& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(IntoClause* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.IntoClause";
  }
  protected:
  explicit IntoClause(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kColNamesFieldNumber = 2,
    kOptionsFieldNumber = 4,
    kAccessMethodFieldNumber = 3,
    kTableSpaceNameFieldNumber = 6,
    kRelFieldNumber = 1,
    kViewQueryFieldNumber = 7,
    kOnCommitFieldNumber = 5,
    kSkipDataFieldNumber = 8,
  };
  // repeated .pg_query.Node col_names = 2 [json_name = "colNames"];
  int col_names_size() const;
  private:
  int _internal_col_names_size() const;
  public:
  void clear_col_names();
  ::pg_query::Node* mutable_col_names(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_col_names();
  private:
  const ::pg_query::Node& _internal_col_names(int index) const;
  ::pg_query::Node* _internal_add_col_names();
  public:
  const ::pg_query::Node& col_names(int index) const;
  ::pg_query::Node* add_col_names();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      col_names() const;

  // repeated .pg_query.Node options = 4 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string access_method = 3 [json_name = "accessMethod"];
  void clear_access_method();
  const std::string& access_method() const;
  void set_access_method(const std::string& value);
  void set_access_method(std::string&& value);
  void set_access_method(const char* value);
  void set_access_method(const char* value, size_t size);
  std::string* mutable_access_method();
  std::string* release_access_method();
  void set_allocated_access_method(std::string* access_method);
  private:
  const std::string& _internal_access_method() const;
  void _internal_set_access_method(const std::string& value);
  std::string* _internal_mutable_access_method();
  public:

  // string table_space_name = 6 [json_name = "tableSpaceName"];
  void clear_table_space_name();
  const std::string& table_space_name() const;
  void set_table_space_name(const std::string& value);
  void set_table_space_name(std::string&& value);
  void set_table_space_name(const char* value);
  void set_table_space_name(const char* value, size_t size);
  std::string* mutable_table_space_name();
  std::string* release_table_space_name();
  void set_allocated_table_space_name(std::string* table_space_name);
  private:
  const std::string& _internal_table_space_name() const;
  void _internal_set_table_space_name(const std::string& value);
  std::string* _internal_mutable_table_space_name();
  public:

  // .pg_query.RangeVar rel = 1 [json_name = "rel"];
  bool has_rel() const;
  private:
  bool _internal_has_rel() const;
  public:
  void clear_rel();
  const ::pg_query::RangeVar& rel() const;
  ::pg_query::RangeVar* release_rel();
  ::pg_query::RangeVar* mutable_rel();
  void set_allocated_rel(::pg_query::RangeVar* rel);
  private:
  const ::pg_query::RangeVar& _internal_rel() const;
  ::pg_query::RangeVar* _internal_mutable_rel();
  public:
  void unsafe_arena_set_allocated_rel(
      ::pg_query::RangeVar* rel);
  ::pg_query::RangeVar* unsafe_arena_release_rel();

  // .pg_query.Node view_query = 7 [json_name = "viewQuery"];
  bool has_view_query() const;
  private:
  bool _internal_has_view_query() const;
  public:
  void clear_view_query();
  const ::pg_query::Node& view_query() const;
  ::pg_query::Node* release_view_query();
  ::pg_query::Node* mutable_view_query();
  void set_allocated_view_query(::pg_query::Node* view_query);
  private:
  const ::pg_query::Node& _internal_view_query() const;
  ::pg_query::Node* _internal_mutable_view_query();
  public:
  void unsafe_arena_set_allocated_view_query(
      ::pg_query::Node* view_query);
  ::pg_query::Node* unsafe_arena_release_view_query();

  // .pg_query.OnCommitAction on_commit = 5 [json_name = "onCommit"];
  void clear_on_commit();
  ::pg_query::OnCommitAction on_commit() const;
  void set_on_commit(::pg_query::OnCommitAction value);
  private:
  ::pg_query::OnCommitAction _internal_on_commit() const;
  void _internal_set_on_commit(::pg_query::OnCommitAction value);
  public:

  // bool skip_data = 8 [json_name = "skipData"];
  void clear_skip_data();
  bool skip_data() const;
  void set_skip_data(bool value);
  private:
  bool _internal_skip_data() const;
  void _internal_set_skip_data(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.IntoClause)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > col_names_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr access_method_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_space_name_;
  ::pg_query::RangeVar* rel_;
  ::pg_query::Node* view_query_;
  int on_commit_;
  bool skip_data_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RawStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RawStmt) */ {
 public:
  inline RawStmt() : RawStmt(nullptr) {}
  virtual ~RawStmt();

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

  inline RawStmt& operator=(const RawStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline RawStmt& operator=(RawStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RawStmt& default_instance();

  static inline const RawStmt* internal_default_instance() {
    return reinterpret_cast<const RawStmt*>(
               &_RawStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    63;

  friend void swap(RawStmt& a, RawStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(RawStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RawStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline RawStmt* New() const final {
    return CreateMaybeMessage<RawStmt>(nullptr);
  }

  RawStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RawStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RawStmt& from);
  void MergeFrom(const RawStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RawStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RawStmt";
  }
  protected:
  explicit RawStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kStmtFieldNumber = 1,
    kStmtLocationFieldNumber = 2,
    kStmtLenFieldNumber = 3,
  };
  // .pg_query.Node stmt = 1 [json_name = "stmt"];
  bool has_stmt() const;
  private:
  bool _internal_has_stmt() const;
  public:
  void clear_stmt();
  const ::pg_query::Node& stmt() const;
  ::pg_query::Node* release_stmt();
  ::pg_query::Node* mutable_stmt();
  void set_allocated_stmt(::pg_query::Node* stmt);
  private:
  const ::pg_query::Node& _internal_stmt() const;
  ::pg_query::Node* _internal_mutable_stmt();
  public:
  void unsafe_arena_set_allocated_stmt(
      ::pg_query::Node* stmt);
  ::pg_query::Node* unsafe_arena_release_stmt();

  // int32 stmt_location = 2 [json_name = "stmt_location"];
  void clear_stmt_location();
  ::PROTOBUF_NAMESPACE_ID::int32 stmt_location() const;
  void set_stmt_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_stmt_location() const;
  void _internal_set_stmt_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 stmt_len = 3 [json_name = "stmt_len"];
  void clear_stmt_len();
  ::PROTOBUF_NAMESPACE_ID::int32 stmt_len() const;
  void set_stmt_len(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_stmt_len() const;
  void _internal_set_stmt_len(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RawStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* stmt_;
  ::PROTOBUF_NAMESPACE_ID::int32 stmt_location_;
  ::PROTOBUF_NAMESPACE_ID::int32 stmt_len_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class Query PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Query) */ {
 public:
  inline Query() : Query(nullptr) {}
  virtual ~Query();

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

  inline Query& operator=(const Query& from) {
    CopyFrom(from);
    return *this;
  }
  inline Query& operator=(Query&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Query& default_instance();

  static inline const Query* internal_default_instance() {
    return reinterpret_cast<const Query*>(
               &_Query_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    64;

  friend void swap(Query& a, Query& b) {
    a.Swap(&b);
  }
  inline void Swap(Query* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Query* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Query* New() const final {
    return CreateMaybeMessage<Query>(nullptr);
  }

  Query* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Query>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Query& from);
  void MergeFrom(const Query& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Query* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.Query";
  }
  protected:
  explicit Query(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCteListFieldNumber = 15,
    kRtableFieldNumber = 16,
    kTargetListFieldNumber = 18,
    kReturningListFieldNumber = 21,
    kGroupClauseFieldNumber = 22,
    kGroupingSetsFieldNumber = 23,
    kWindowClauseFieldNumber = 25,
    kDistinctClauseFieldNumber = 26,
    kSortClauseFieldNumber = 27,
    kRowMarksFieldNumber = 31,
    kConstraintDepsFieldNumber = 33,
    kWithCheckOptionsFieldNumber = 34,
    kUtilityStmtFieldNumber = 4,
    kJointreeFieldNumber = 17,
    kOnConflictFieldNumber = 20,
    kHavingQualFieldNumber = 24,
    kLimitOffsetFieldNumber = 28,
    kLimitCountFieldNumber = 29,
    kSetOperationsFieldNumber = 32,
    kCommandTypeFieldNumber = 1,
    kQuerySourceFieldNumber = 2,
    kResultRelationFieldNumber = 5,
    kCanSetTagFieldNumber = 3,
    kHasAggsFieldNumber = 6,
    kHasWindowFuncsFieldNumber = 7,
    kHasTargetSrfsFieldNumber = 8,
    kHasSubLinksFieldNumber = 9,
    kHasDistinctOnFieldNumber = 10,
    kHasRecursiveFieldNumber = 11,
    kHasModifyingCteFieldNumber = 12,
    kHasForUpdateFieldNumber = 13,
    kHasRowSecurityFieldNumber = 14,
    kOverrideFieldNumber = 19,
    kLimitOptionFieldNumber = 30,
    kStmtLocationFieldNumber = 35,
    kStmtLenFieldNumber = 36,
  };
  // repeated .pg_query.Node cte_list = 15 [json_name = "cteList"];
  int cte_list_size() const;
  private:
  int _internal_cte_list_size() const;
  public:
  void clear_cte_list();
  ::pg_query::Node* mutable_cte_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_cte_list();
  private:
  const ::pg_query::Node& _internal_cte_list(int index) const;
  ::pg_query::Node* _internal_add_cte_list();
  public:
  const ::pg_query::Node& cte_list(int index) const;
  ::pg_query::Node* add_cte_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      cte_list() const;

  // repeated .pg_query.Node rtable = 16 [json_name = "rtable"];
  int rtable_size() const;
  private:
  int _internal_rtable_size() const;
  public:
  void clear_rtable();
  ::pg_query::Node* mutable_rtable(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_rtable();
  private:
  const ::pg_query::Node& _internal_rtable(int index) const;
  ::pg_query::Node* _internal_add_rtable();
  public:
  const ::pg_query::Node& rtable(int index) const;
  ::pg_query::Node* add_rtable();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      rtable() const;

  // repeated .pg_query.Node target_list = 18 [json_name = "targetList"];
  int target_list_size() const;
  private:
  int _internal_target_list_size() const;
  public:
  void clear_target_list();
  ::pg_query::Node* mutable_target_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_target_list();
  private:
  const ::pg_query::Node& _internal_target_list(int index) const;
  ::pg_query::Node* _internal_add_target_list();
  public:
  const ::pg_query::Node& target_list(int index) const;
  ::pg_query::Node* add_target_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      target_list() const;

  // repeated .pg_query.Node returning_list = 21 [json_name = "returningList"];
  int returning_list_size() const;
  private:
  int _internal_returning_list_size() const;
  public:
  void clear_returning_list();
  ::pg_query::Node* mutable_returning_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_returning_list();
  private:
  const ::pg_query::Node& _internal_returning_list(int index) const;
  ::pg_query::Node* _internal_add_returning_list();
  public:
  const ::pg_query::Node& returning_list(int index) const;
  ::pg_query::Node* add_returning_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      returning_list() const;

  // repeated .pg_query.Node group_clause = 22 [json_name = "groupClause"];
  int group_clause_size() const;
  private:
  int _internal_group_clause_size() const;
  public:
  void clear_group_clause();
  ::pg_query::Node* mutable_group_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_group_clause();
  private:
  const ::pg_query::Node& _internal_group_clause(int index) const;
  ::pg_query::Node* _internal_add_group_clause();
  public:
  const ::pg_query::Node& group_clause(int index) const;
  ::pg_query::Node* add_group_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      group_clause() const;

  // repeated .pg_query.Node grouping_sets = 23 [json_name = "groupingSets"];
  int grouping_sets_size() const;
  private:
  int _internal_grouping_sets_size() const;
  public:
  void clear_grouping_sets();
  ::pg_query::Node* mutable_grouping_sets(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_grouping_sets();
  private:
  const ::pg_query::Node& _internal_grouping_sets(int index) const;
  ::pg_query::Node* _internal_add_grouping_sets();
  public:
  const ::pg_query::Node& grouping_sets(int index) const;
  ::pg_query::Node* add_grouping_sets();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      grouping_sets() const;

  // repeated .pg_query.Node window_clause = 25 [json_name = "windowClause"];
  int window_clause_size() const;
  private:
  int _internal_window_clause_size() const;
  public:
  void clear_window_clause();
  ::pg_query::Node* mutable_window_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_window_clause();
  private:
  const ::pg_query::Node& _internal_window_clause(int index) const;
  ::pg_query::Node* _internal_add_window_clause();
  public:
  const ::pg_query::Node& window_clause(int index) const;
  ::pg_query::Node* add_window_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      window_clause() const;

  // repeated .pg_query.Node distinct_clause = 26 [json_name = "distinctClause"];
  int distinct_clause_size() const;
  private:
  int _internal_distinct_clause_size() const;
  public:
  void clear_distinct_clause();
  ::pg_query::Node* mutable_distinct_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_distinct_clause();
  private:
  const ::pg_query::Node& _internal_distinct_clause(int index) const;
  ::pg_query::Node* _internal_add_distinct_clause();
  public:
  const ::pg_query::Node& distinct_clause(int index) const;
  ::pg_query::Node* add_distinct_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      distinct_clause() const;

  // repeated .pg_query.Node sort_clause = 27 [json_name = "sortClause"];
  int sort_clause_size() const;
  private:
  int _internal_sort_clause_size() const;
  public:
  void clear_sort_clause();
  ::pg_query::Node* mutable_sort_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_sort_clause();
  private:
  const ::pg_query::Node& _internal_sort_clause(int index) const;
  ::pg_query::Node* _internal_add_sort_clause();
  public:
  const ::pg_query::Node& sort_clause(int index) const;
  ::pg_query::Node* add_sort_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      sort_clause() const;

  // repeated .pg_query.Node row_marks = 31 [json_name = "rowMarks"];
  int row_marks_size() const;
  private:
  int _internal_row_marks_size() const;
  public:
  void clear_row_marks();
  ::pg_query::Node* mutable_row_marks(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_row_marks();
  private:
  const ::pg_query::Node& _internal_row_marks(int index) const;
  ::pg_query::Node* _internal_add_row_marks();
  public:
  const ::pg_query::Node& row_marks(int index) const;
  ::pg_query::Node* add_row_marks();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      row_marks() const;

  // repeated .pg_query.Node constraint_deps = 33 [json_name = "constraintDeps"];
  int constraint_deps_size() const;
  private:
  int _internal_constraint_deps_size() const;
  public:
  void clear_constraint_deps();
  ::pg_query::Node* mutable_constraint_deps(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_constraint_deps();
  private:
  const ::pg_query::Node& _internal_constraint_deps(int index) const;
  ::pg_query::Node* _internal_add_constraint_deps();
  public:
  const ::pg_query::Node& constraint_deps(int index) const;
  ::pg_query::Node* add_constraint_deps();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      constraint_deps() const;

  // repeated .pg_query.Node with_check_options = 34 [json_name = "withCheckOptions"];
  int with_check_options_size() const;
  private:
  int _internal_with_check_options_size() const;
  public:
  void clear_with_check_options();
  ::pg_query::Node* mutable_with_check_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_with_check_options();
  private:
  const ::pg_query::Node& _internal_with_check_options(int index) const;
  ::pg_query::Node* _internal_add_with_check_options();
  public:
  const ::pg_query::Node& with_check_options(int index) const;
  ::pg_query::Node* add_with_check_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      with_check_options() const;

  // .pg_query.Node utility_stmt = 4 [json_name = "utilityStmt"];
  bool has_utility_stmt() const;
  private:
  bool _internal_has_utility_stmt() const;
  public:
  void clear_utility_stmt();
  const ::pg_query::Node& utility_stmt() const;
  ::pg_query::Node* release_utility_stmt();
  ::pg_query::Node* mutable_utility_stmt();
  void set_allocated_utility_stmt(::pg_query::Node* utility_stmt);
  private:
  const ::pg_query::Node& _internal_utility_stmt() const;
  ::pg_query::Node* _internal_mutable_utility_stmt();
  public:
  void unsafe_arena_set_allocated_utility_stmt(
      ::pg_query::Node* utility_stmt);
  ::pg_query::Node* unsafe_arena_release_utility_stmt();

  // .pg_query.FromExpr jointree = 17 [json_name = "jointree"];
  bool has_jointree() const;
  private:
  bool _internal_has_jointree() const;
  public:
  void clear_jointree();
  const ::pg_query::FromExpr& jointree() const;
  ::pg_query::FromExpr* release_jointree();
  ::pg_query::FromExpr* mutable_jointree();
  void set_allocated_jointree(::pg_query::FromExpr* jointree);
  private:
  const ::pg_query::FromExpr& _internal_jointree() const;
  ::pg_query::FromExpr* _internal_mutable_jointree();
  public:
  void unsafe_arena_set_allocated_jointree(
      ::pg_query::FromExpr* jointree);
  ::pg_query::FromExpr* unsafe_arena_release_jointree();

  // .pg_query.OnConflictExpr on_conflict = 20 [json_name = "onConflict"];
  bool has_on_conflict() const;
  private:
  bool _internal_has_on_conflict() const;
  public:
  void clear_on_conflict();
  const ::pg_query::OnConflictExpr& on_conflict() const;
  ::pg_query::OnConflictExpr* release_on_conflict();
  ::pg_query::OnConflictExpr* mutable_on_conflict();
  void set_allocated_on_conflict(::pg_query::OnConflictExpr* on_conflict);
  private:
  const ::pg_query::OnConflictExpr& _internal_on_conflict() const;
  ::pg_query::OnConflictExpr* _internal_mutable_on_conflict();
  public:
  void unsafe_arena_set_allocated_on_conflict(
      ::pg_query::OnConflictExpr* on_conflict);
  ::pg_query::OnConflictExpr* unsafe_arena_release_on_conflict();

  // .pg_query.Node having_qual = 24 [json_name = "havingQual"];
  bool has_having_qual() const;
  private:
  bool _internal_has_having_qual() const;
  public:
  void clear_having_qual();
  const ::pg_query::Node& having_qual() const;
  ::pg_query::Node* release_having_qual();
  ::pg_query::Node* mutable_having_qual();
  void set_allocated_having_qual(::pg_query::Node* having_qual);
  private:
  const ::pg_query::Node& _internal_having_qual() const;
  ::pg_query::Node* _internal_mutable_having_qual();
  public:
  void unsafe_arena_set_allocated_having_qual(
      ::pg_query::Node* having_qual);
  ::pg_query::Node* unsafe_arena_release_having_qual();

  // .pg_query.Node limit_offset = 28 [json_name = "limitOffset"];
  bool has_limit_offset() const;
  private:
  bool _internal_has_limit_offset() const;
  public:
  void clear_limit_offset();
  const ::pg_query::Node& limit_offset() const;
  ::pg_query::Node* release_limit_offset();
  ::pg_query::Node* mutable_limit_offset();
  void set_allocated_limit_offset(::pg_query::Node* limit_offset);
  private:
  const ::pg_query::Node& _internal_limit_offset() const;
  ::pg_query::Node* _internal_mutable_limit_offset();
  public:
  void unsafe_arena_set_allocated_limit_offset(
      ::pg_query::Node* limit_offset);
  ::pg_query::Node* unsafe_arena_release_limit_offset();

  // .pg_query.Node limit_count = 29 [json_name = "limitCount"];
  bool has_limit_count() const;
  private:
  bool _internal_has_limit_count() const;
  public:
  void clear_limit_count();
  const ::pg_query::Node& limit_count() const;
  ::pg_query::Node* release_limit_count();
  ::pg_query::Node* mutable_limit_count();
  void set_allocated_limit_count(::pg_query::Node* limit_count);
  private:
  const ::pg_query::Node& _internal_limit_count() const;
  ::pg_query::Node* _internal_mutable_limit_count();
  public:
  void unsafe_arena_set_allocated_limit_count(
      ::pg_query::Node* limit_count);
  ::pg_query::Node* unsafe_arena_release_limit_count();

  // .pg_query.Node set_operations = 32 [json_name = "setOperations"];
  bool has_set_operations() const;
  private:
  bool _internal_has_set_operations() const;
  public:
  void clear_set_operations();
  const ::pg_query::Node& set_operations() const;
  ::pg_query::Node* release_set_operations();
  ::pg_query::Node* mutable_set_operations();
  void set_allocated_set_operations(::pg_query::Node* set_operations);
  private:
  const ::pg_query::Node& _internal_set_operations() const;
  ::pg_query::Node* _internal_mutable_set_operations();
  public:
  void unsafe_arena_set_allocated_set_operations(
      ::pg_query::Node* set_operations);
  ::pg_query::Node* unsafe_arena_release_set_operations();

  // .pg_query.CmdType command_type = 1 [json_name = "commandType"];
  void clear_command_type();
  ::pg_query::CmdType command_type() const;
  void set_command_type(::pg_query::CmdType value);
  private:
  ::pg_query::CmdType _internal_command_type() const;
  void _internal_set_command_type(::pg_query::CmdType value);
  public:

  // .pg_query.QuerySource query_source = 2 [json_name = "querySource"];
  void clear_query_source();
  ::pg_query::QuerySource query_source() const;
  void set_query_source(::pg_query::QuerySource value);
  private:
  ::pg_query::QuerySource _internal_query_source() const;
  void _internal_set_query_source(::pg_query::QuerySource value);
  public:

  // int32 result_relation = 5 [json_name = "resultRelation"];
  void clear_result_relation();
  ::PROTOBUF_NAMESPACE_ID::int32 result_relation() const;
  void set_result_relation(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_result_relation() const;
  void _internal_set_result_relation(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool can_set_tag = 3 [json_name = "canSetTag"];
  void clear_can_set_tag();
  bool can_set_tag() const;
  void set_can_set_tag(bool value);
  private:
  bool _internal_can_set_tag() const;
  void _internal_set_can_set_tag(bool value);
  public:

  // bool has_aggs = 6 [json_name = "hasAggs"];
  void clear_has_aggs();
  bool has_aggs() const;
  void set_has_aggs(bool value);
  private:
  bool _internal_has_aggs() const;
  void _internal_set_has_aggs(bool value);
  public:

  // bool has_window_funcs = 7 [json_name = "hasWindowFuncs"];
  void clear_has_window_funcs();
  bool has_window_funcs() const;
  void set_has_window_funcs(bool value);
  private:
  bool _internal_has_window_funcs() const;
  void _internal_set_has_window_funcs(bool value);
  public:

  // bool has_target_srfs = 8 [json_name = "hasTargetSRFs"];
  void clear_has_target_srfs();
  bool has_target_srfs() const;
  void set_has_target_srfs(bool value);
  private:
  bool _internal_has_target_srfs() const;
  void _internal_set_has_target_srfs(bool value);
  public:

  // bool has_sub_links = 9 [json_name = "hasSubLinks"];
  void clear_has_sub_links();
  bool has_sub_links() const;
  void set_has_sub_links(bool value);
  private:
  bool _internal_has_sub_links() const;
  void _internal_set_has_sub_links(bool value);
  public:

  // bool has_distinct_on = 10 [json_name = "hasDistinctOn"];
  void clear_has_distinct_on();
  bool has_distinct_on() const;
  void set_has_distinct_on(bool value);
  private:
  bool _internal_has_distinct_on() const;
  void _internal_set_has_distinct_on(bool value);
  public:

  // bool has_recursive = 11 [json_name = "hasRecursive"];
  void clear_has_recursive();
  bool has_recursive() const;
  void set_has_recursive(bool value);
  private:
  bool _internal_has_recursive() const;
  void _internal_set_has_recursive(bool value);
  public:

  // bool has_modifying_cte = 12 [json_name = "hasModifyingCTE"];
  void clear_has_modifying_cte();
  bool has_modifying_cte() const;
  void set_has_modifying_cte(bool value);
  private:
  bool _internal_has_modifying_cte() const;
  void _internal_set_has_modifying_cte(bool value);
  public:

  // bool has_for_update = 13 [json_name = "hasForUpdate"];
  void clear_has_for_update();
  bool has_for_update() const;
  void set_has_for_update(bool value);
  private:
  bool _internal_has_for_update() const;
  void _internal_set_has_for_update(bool value);
  public:

  // bool has_row_security = 14 [json_name = "hasRowSecurity"];
  void clear_has_row_security();
  bool has_row_security() const;
  void set_has_row_security(bool value);
  private:
  bool _internal_has_row_security() const;
  void _internal_set_has_row_security(bool value);
  public:

  // .pg_query.OverridingKind override = 19 [json_name = "override"];
  void clear_override();
  ::pg_query::OverridingKind override() const;
  void set_override(::pg_query::OverridingKind value);
  private:
  ::pg_query::OverridingKind _internal_override() const;
  void _internal_set_override(::pg_query::OverridingKind value);
  public:

  // .pg_query.LimitOption limit_option = 30 [json_name = "limitOption"];
  void clear_limit_option();
  ::pg_query::LimitOption limit_option() const;
  void set_limit_option(::pg_query::LimitOption value);
  private:
  ::pg_query::LimitOption _internal_limit_option() const;
  void _internal_set_limit_option(::pg_query::LimitOption value);
  public:

  // int32 stmt_location = 35 [json_name = "stmt_location"];
  void clear_stmt_location();
  ::PROTOBUF_NAMESPACE_ID::int32 stmt_location() const;
  void set_stmt_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_stmt_location() const;
  void _internal_set_stmt_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 stmt_len = 36 [json_name = "stmt_len"];
  void clear_stmt_len();
  ::PROTOBUF_NAMESPACE_ID::int32 stmt_len() const;
  void set_stmt_len(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_stmt_len() const;
  void _internal_set_stmt_len(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.Query)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > cte_list_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > rtable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > target_list_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > returning_list_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > group_clause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > grouping_sets_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > window_clause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > distinct_clause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > sort_clause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > row_marks_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > constraint_deps_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > with_check_options_;
  ::pg_query::Node* utility_stmt_;
  ::pg_query::FromExpr* jointree_;
  ::pg_query::OnConflictExpr* on_conflict_;
  ::pg_query::Node* having_qual_;
  ::pg_query::Node* limit_offset_;
  ::pg_query::Node* limit_count_;
  ::pg_query::Node* set_operations_;
  int command_type_;
  int query_source_;
  ::PROTOBUF_NAMESPACE_ID::int32 result_relation_;
  bool can_set_tag_;
  bool has_aggs_;
  bool has_window_funcs_;
  bool has_target_srfs_;
  bool has_sub_links_;
  bool has_distinct_on_;
  bool has_recursive_;
  bool has_modifying_cte_;
  bool has_for_update_;
  bool has_row_security_;
  int override_;
  int limit_option_;
  ::PROTOBUF_NAMESPACE_ID::int32 stmt_location_;
  ::PROTOBUF_NAMESPACE_ID::int32 stmt_len_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class InsertStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.InsertStmt) */ {
 public:
  inline InsertStmt() : InsertStmt(nullptr) {}
  virtual ~InsertStmt();

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

  inline InsertStmt& operator=(const InsertStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline InsertStmt& operator=(InsertStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const InsertStmt& default_instance();

  static inline const InsertStmt* internal_default_instance() {
    return reinterpret_cast<const InsertStmt*>(
               &_InsertStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    65;

  friend void swap(InsertStmt& a, InsertStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(InsertStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InsertStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline InsertStmt* New() const final {
    return CreateMaybeMessage<InsertStmt>(nullptr);
  }

  InsertStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<InsertStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const InsertStmt& from);
  void MergeFrom(const InsertStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InsertStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.InsertStmt";
  }
  protected:
  explicit InsertStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kColsFieldNumber = 2,
    kReturningListFieldNumber = 5,
    kRelationFieldNumber = 1,
    kSelectStmtFieldNumber = 3,
    kOnConflictClauseFieldNumber = 4,
    kWithClauseFieldNumber = 6,
    kOverrideFieldNumber = 7,
  };
  // repeated .pg_query.Node cols = 2 [json_name = "cols"];
  int cols_size() const;
  private:
  int _internal_cols_size() const;
  public:
  void clear_cols();
  ::pg_query::Node* mutable_cols(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_cols();
  private:
  const ::pg_query::Node& _internal_cols(int index) const;
  ::pg_query::Node* _internal_add_cols();
  public:
  const ::pg_query::Node& cols(int index) const;
  ::pg_query::Node* add_cols();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      cols() const;

  // repeated .pg_query.Node returning_list = 5 [json_name = "returningList"];
  int returning_list_size() const;
  private:
  int _internal_returning_list_size() const;
  public:
  void clear_returning_list();
  ::pg_query::Node* mutable_returning_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_returning_list();
  private:
  const ::pg_query::Node& _internal_returning_list(int index) const;
  ::pg_query::Node* _internal_add_returning_list();
  public:
  const ::pg_query::Node& returning_list(int index) const;
  ::pg_query::Node* add_returning_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      returning_list() const;

  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.Node select_stmt = 3 [json_name = "selectStmt"];
  bool has_select_stmt() const;
  private:
  bool _internal_has_select_stmt() const;
  public:
  void clear_select_stmt();
  const ::pg_query::Node& select_stmt() const;
  ::pg_query::Node* release_select_stmt();
  ::pg_query::Node* mutable_select_stmt();
  void set_allocated_select_stmt(::pg_query::Node* select_stmt);
  private:
  const ::pg_query::Node& _internal_select_stmt() const;
  ::pg_query::Node* _internal_mutable_select_stmt();
  public:
  void unsafe_arena_set_allocated_select_stmt(
      ::pg_query::Node* select_stmt);
  ::pg_query::Node* unsafe_arena_release_select_stmt();

  // .pg_query.OnConflictClause on_conflict_clause = 4 [json_name = "onConflictClause"];
  bool has_on_conflict_clause() const;
  private:
  bool _internal_has_on_conflict_clause() const;
  public:
  void clear_on_conflict_clause();
  const ::pg_query::OnConflictClause& on_conflict_clause() const;
  ::pg_query::OnConflictClause* release_on_conflict_clause();
  ::pg_query::OnConflictClause* mutable_on_conflict_clause();
  void set_allocated_on_conflict_clause(::pg_query::OnConflictClause* on_conflict_clause);
  private:
  const ::pg_query::OnConflictClause& _internal_on_conflict_clause() const;
  ::pg_query::OnConflictClause* _internal_mutable_on_conflict_clause();
  public:
  void unsafe_arena_set_allocated_on_conflict_clause(
      ::pg_query::OnConflictClause* on_conflict_clause);
  ::pg_query::OnConflictClause* unsafe_arena_release_on_conflict_clause();

  // .pg_query.WithClause with_clause = 6 [json_name = "withClause"];
  bool has_with_clause() const;
  private:
  bool _internal_has_with_clause() const;
  public:
  void clear_with_clause();
  const ::pg_query::WithClause& with_clause() const;
  ::pg_query::WithClause* release_with_clause();
  ::pg_query::WithClause* mutable_with_clause();
  void set_allocated_with_clause(::pg_query::WithClause* with_clause);
  private:
  const ::pg_query::WithClause& _internal_with_clause() const;
  ::pg_query::WithClause* _internal_mutable_with_clause();
  public:
  void unsafe_arena_set_allocated_with_clause(
      ::pg_query::WithClause* with_clause);
  ::pg_query::WithClause* unsafe_arena_release_with_clause();

  // .pg_query.OverridingKind override = 7 [json_name = "override"];
  void clear_override();
  ::pg_query::OverridingKind override() const;
  void set_override(::pg_query::OverridingKind value);
  private:
  ::pg_query::OverridingKind _internal_override() const;
  void _internal_set_override(::pg_query::OverridingKind value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.InsertStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > cols_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > returning_list_;
  ::pg_query::RangeVar* relation_;
  ::pg_query::Node* select_stmt_;
  ::pg_query::OnConflictClause* on_conflict_clause_;
  ::pg_query::WithClause* with_clause_;
  int override_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class DeleteStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DeleteStmt) */ {
 public:
  inline DeleteStmt() : DeleteStmt(nullptr) {}
  virtual ~DeleteStmt();

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

  inline DeleteStmt& operator=(const DeleteStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeleteStmt& operator=(DeleteStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DeleteStmt& default_instance();

  static inline const DeleteStmt* internal_default_instance() {
    return reinterpret_cast<const DeleteStmt*>(
               &_DeleteStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    66;

  friend void swap(DeleteStmt& a, DeleteStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(DeleteStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DeleteStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline DeleteStmt* New() const final {
    return CreateMaybeMessage<DeleteStmt>(nullptr);
  }

  DeleteStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeleteStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DeleteStmt& from);
  void MergeFrom(const DeleteStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DeleteStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DeleteStmt";
  }
  protected:
  explicit DeleteStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kUsingClauseFieldNumber = 2,
    kReturningListFieldNumber = 4,
    kRelationFieldNumber = 1,
    kWhereClauseFieldNumber = 3,
    kWithClauseFieldNumber = 5,
  };
  // repeated .pg_query.Node using_clause = 2 [json_name = "usingClause"];
  int using_clause_size() const;
  private:
  int _internal_using_clause_size() const;
  public:
  void clear_using_clause();
  ::pg_query::Node* mutable_using_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_using_clause();
  private:
  const ::pg_query::Node& _internal_using_clause(int index) const;
  ::pg_query::Node* _internal_add_using_clause();
  public:
  const ::pg_query::Node& using_clause(int index) const;
  ::pg_query::Node* add_using_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      using_clause() const;

  // repeated .pg_query.Node returning_list = 4 [json_name = "returningList"];
  int returning_list_size() const;
  private:
  int _internal_returning_list_size() const;
  public:
  void clear_returning_list();
  ::pg_query::Node* mutable_returning_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_returning_list();
  private:
  const ::pg_query::Node& _internal_returning_list(int index) const;
  ::pg_query::Node* _internal_add_returning_list();
  public:
  const ::pg_query::Node& returning_list(int index) const;
  ::pg_query::Node* add_returning_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      returning_list() const;

  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.Node where_clause = 3 [json_name = "whereClause"];
  bool has_where_clause() const;
  private:
  bool _internal_has_where_clause() const;
  public:
  void clear_where_clause();
  const ::pg_query::Node& where_clause() const;
  ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* where_clause);
  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();
  public:
  void unsafe_arena_set_allocated_where_clause(
      ::pg_query::Node* where_clause);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  // .pg_query.WithClause with_clause = 5 [json_name = "withClause"];
  bool has_with_clause() const;
  private:
  bool _internal_has_with_clause() const;
  public:
  void clear_with_clause();
  const ::pg_query::WithClause& with_clause() const;
  ::pg_query::WithClause* release_with_clause();
  ::pg_query::WithClause* mutable_with_clause();
  void set_allocated_with_clause(::pg_query::WithClause* with_clause);
  private:
  const ::pg_query::WithClause& _internal_with_clause() const;
  ::pg_query::WithClause* _internal_mutable_with_clause();
  public:
  void unsafe_arena_set_allocated_with_clause(
      ::pg_query::WithClause* with_clause);
  ::pg_query::WithClause* unsafe_arena_release_with_clause();

  // @@protoc_insertion_point(class_scope:pg_query.DeleteStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > using_clause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > returning_list_;
  ::pg_query::RangeVar* relation_;
  ::pg_query::Node* where_clause_;
  ::pg_query::WithClause* with_clause_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class UpdateStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.UpdateStmt) */ {
 public:
  inline UpdateStmt() : UpdateStmt(nullptr) {}
  virtual ~UpdateStmt();

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

  inline UpdateStmt& operator=(const UpdateStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline UpdateStmt& operator=(UpdateStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const UpdateStmt& default_instance();

  static inline const UpdateStmt* internal_default_instance() {
    return reinterpret_cast<const UpdateStmt*>(
               &_UpdateStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    67;

  friend void swap(UpdateStmt& a, UpdateStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(UpdateStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(UpdateStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline UpdateStmt* New() const final {
    return CreateMaybeMessage<UpdateStmt>(nullptr);
  }

  UpdateStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<UpdateStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const UpdateStmt& from);
  void MergeFrom(const UpdateStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(UpdateStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.UpdateStmt";
  }
  protected:
  explicit UpdateStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTargetListFieldNumber = 2,
    kFromClauseFieldNumber = 4,
    kReturningListFieldNumber = 5,
    kRelationFieldNumber = 1,
    kWhereClauseFieldNumber = 3,
    kWithClauseFieldNumber = 6,
  };
  // repeated .pg_query.Node target_list = 2 [json_name = "targetList"];
  int target_list_size() const;
  private:
  int _internal_target_list_size() const;
  public:
  void clear_target_list();
  ::pg_query::Node* mutable_target_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_target_list();
  private:
  const ::pg_query::Node& _internal_target_list(int index) const;
  ::pg_query::Node* _internal_add_target_list();
  public:
  const ::pg_query::Node& target_list(int index) const;
  ::pg_query::Node* add_target_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      target_list() const;

  // repeated .pg_query.Node from_clause = 4 [json_name = "fromClause"];
  int from_clause_size() const;
  private:
  int _internal_from_clause_size() const;
  public:
  void clear_from_clause();
  ::pg_query::Node* mutable_from_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_from_clause();
  private:
  const ::pg_query::Node& _internal_from_clause(int index) const;
  ::pg_query::Node* _internal_add_from_clause();
  public:
  const ::pg_query::Node& from_clause(int index) const;
  ::pg_query::Node* add_from_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      from_clause() const;

  // repeated .pg_query.Node returning_list = 5 [json_name = "returningList"];
  int returning_list_size() const;
  private:
  int _internal_returning_list_size() const;
  public:
  void clear_returning_list();
  ::pg_query::Node* mutable_returning_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_returning_list();
  private:
  const ::pg_query::Node& _internal_returning_list(int index) const;
  ::pg_query::Node* _internal_add_returning_list();
  public:
  const ::pg_query::Node& returning_list(int index) const;
  ::pg_query::Node* add_returning_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      returning_list() const;

  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.Node where_clause = 3 [json_name = "whereClause"];
  bool has_where_clause() const;
  private:
  bool _internal_has_where_clause() const;
  public:
  void clear_where_clause();
  const ::pg_query::Node& where_clause() const;
  ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* where_clause);
  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();
  public:
  void unsafe_arena_set_allocated_where_clause(
      ::pg_query::Node* where_clause);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  // .pg_query.WithClause with_clause = 6 [json_name = "withClause"];
  bool has_with_clause() const;
  private:
  bool _internal_has_with_clause() const;
  public:
  void clear_with_clause();
  const ::pg_query::WithClause& with_clause() const;
  ::pg_query::WithClause* release_with_clause();
  ::pg_query::WithClause* mutable_with_clause();
  void set_allocated_with_clause(::pg_query::WithClause* with_clause);
  private:
  const ::pg_query::WithClause& _internal_with_clause() const;
  ::pg_query::WithClause* _internal_mutable_with_clause();
  public:
  void unsafe_arena_set_allocated_with_clause(
      ::pg_query::WithClause* with_clause);
  ::pg_query::WithClause* unsafe_arena_release_with_clause();

  // @@protoc_insertion_point(class_scope:pg_query.UpdateStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > target_list_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > from_clause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > returning_list_;
  ::pg_query::RangeVar* relation_;
  ::pg_query::Node* where_clause_;
  ::pg_query::WithClause* with_clause_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class SelectStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SelectStmt) */ {
 public:
  inline SelectStmt() : SelectStmt(nullptr) {}
  virtual ~SelectStmt();

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

  inline SelectStmt& operator=(const SelectStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline SelectStmt& operator=(SelectStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SelectStmt& default_instance();

  static inline const SelectStmt* internal_default_instance() {
    return reinterpret_cast<const SelectStmt*>(
               &_SelectStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    68;

  friend void swap(SelectStmt& a, SelectStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(SelectStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SelectStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SelectStmt* New() const final {
    return CreateMaybeMessage<SelectStmt>(nullptr);
  }

  SelectStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SelectStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SelectStmt& from);
  void MergeFrom(const SelectStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SelectStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.SelectStmt";
  }
  protected:
  explicit SelectStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDistinctClauseFieldNumber = 1,
    kTargetListFieldNumber = 3,
    kFromClauseFieldNumber = 4,
    kGroupClauseFieldNumber = 6,
    kWindowClauseFieldNumber = 8,
    kValuesListsFieldNumber = 9,
    kSortClauseFieldNumber = 10,
    kLockingClauseFieldNumber = 14,
    kIntoClauseFieldNumber = 2,
    kWhereClauseFieldNumber = 5,
    kHavingClauseFieldNumber = 7,
    kLimitOffsetFieldNumber = 11,
    kLimitCountFieldNumber = 12,
    kWithClauseFieldNumber = 15,
    kLargFieldNumber = 18,
    kRargFieldNumber = 19,
    kLimitOptionFieldNumber = 13,
    kOpFieldNumber = 16,
    kAllFieldNumber = 17,
  };
  // repeated .pg_query.Node distinct_clause = 1 [json_name = "distinctClause"];
  int distinct_clause_size() const;
  private:
  int _internal_distinct_clause_size() const;
  public:
  void clear_distinct_clause();
  ::pg_query::Node* mutable_distinct_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_distinct_clause();
  private:
  const ::pg_query::Node& _internal_distinct_clause(int index) const;
  ::pg_query::Node* _internal_add_distinct_clause();
  public:
  const ::pg_query::Node& distinct_clause(int index) const;
  ::pg_query::Node* add_distinct_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      distinct_clause() const;

  // repeated .pg_query.Node target_list = 3 [json_name = "targetList"];
  int target_list_size() const;
  private:
  int _internal_target_list_size() const;
  public:
  void clear_target_list();
  ::pg_query::Node* mutable_target_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_target_list();
  private:
  const ::pg_query::Node& _internal_target_list(int index) const;
  ::pg_query::Node* _internal_add_target_list();
  public:
  const ::pg_query::Node& target_list(int index) const;
  ::pg_query::Node* add_target_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      target_list() const;

  // repeated .pg_query.Node from_clause = 4 [json_name = "fromClause"];
  int from_clause_size() const;
  private:
  int _internal_from_clause_size() const;
  public:
  void clear_from_clause();
  ::pg_query::Node* mutable_from_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_from_clause();
  private:
  const ::pg_query::Node& _internal_from_clause(int index) const;
  ::pg_query::Node* _internal_add_from_clause();
  public:
  const ::pg_query::Node& from_clause(int index) const;
  ::pg_query::Node* add_from_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      from_clause() const;

  // repeated .pg_query.Node group_clause = 6 [json_name = "groupClause"];
  int group_clause_size() const;
  private:
  int _internal_group_clause_size() const;
  public:
  void clear_group_clause();
  ::pg_query::Node* mutable_group_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_group_clause();
  private:
  const ::pg_query::Node& _internal_group_clause(int index) const;
  ::pg_query::Node* _internal_add_group_clause();
  public:
  const ::pg_query::Node& group_clause(int index) const;
  ::pg_query::Node* add_group_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      group_clause() const;

  // repeated .pg_query.Node window_clause = 8 [json_name = "windowClause"];
  int window_clause_size() const;
  private:
  int _internal_window_clause_size() const;
  public:
  void clear_window_clause();
  ::pg_query::Node* mutable_window_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_window_clause();
  private:
  const ::pg_query::Node& _internal_window_clause(int index) const;
  ::pg_query::Node* _internal_add_window_clause();
  public:
  const ::pg_query::Node& window_clause(int index) const;
  ::pg_query::Node* add_window_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      window_clause() const;

  // repeated .pg_query.Node values_lists = 9 [json_name = "valuesLists"];
  int values_lists_size() const;
  private:
  int _internal_values_lists_size() const;
  public:
  void clear_values_lists();
  ::pg_query::Node* mutable_values_lists(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_values_lists();
  private:
  const ::pg_query::Node& _internal_values_lists(int index) const;
  ::pg_query::Node* _internal_add_values_lists();
  public:
  const ::pg_query::Node& values_lists(int index) const;
  ::pg_query::Node* add_values_lists();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      values_lists() const;

  // repeated .pg_query.Node sort_clause = 10 [json_name = "sortClause"];
  int sort_clause_size() const;
  private:
  int _internal_sort_clause_size() const;
  public:
  void clear_sort_clause();
  ::pg_query::Node* mutable_sort_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_sort_clause();
  private:
  const ::pg_query::Node& _internal_sort_clause(int index) const;
  ::pg_query::Node* _internal_add_sort_clause();
  public:
  const ::pg_query::Node& sort_clause(int index) const;
  ::pg_query::Node* add_sort_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      sort_clause() const;

  // repeated .pg_query.Node locking_clause = 14 [json_name = "lockingClause"];
  int locking_clause_size() const;
  private:
  int _internal_locking_clause_size() const;
  public:
  void clear_locking_clause();
  ::pg_query::Node* mutable_locking_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_locking_clause();
  private:
  const ::pg_query::Node& _internal_locking_clause(int index) const;
  ::pg_query::Node* _internal_add_locking_clause();
  public:
  const ::pg_query::Node& locking_clause(int index) const;
  ::pg_query::Node* add_locking_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      locking_clause() const;

  // .pg_query.IntoClause into_clause = 2 [json_name = "intoClause"];
  bool has_into_clause() const;
  private:
  bool _internal_has_into_clause() const;
  public:
  void clear_into_clause();
  const ::pg_query::IntoClause& into_clause() const;
  ::pg_query::IntoClause* release_into_clause();
  ::pg_query::IntoClause* mutable_into_clause();
  void set_allocated_into_clause(::pg_query::IntoClause* into_clause);
  private:
  const ::pg_query::IntoClause& _internal_into_clause() const;
  ::pg_query::IntoClause* _internal_mutable_into_clause();
  public:
  void unsafe_arena_set_allocated_into_clause(
      ::pg_query::IntoClause* into_clause);
  ::pg_query::IntoClause* unsafe_arena_release_into_clause();

  // .pg_query.Node where_clause = 5 [json_name = "whereClause"];
  bool has_where_clause() const;
  private:
  bool _internal_has_where_clause() const;
  public:
  void clear_where_clause();
  const ::pg_query::Node& where_clause() const;
  ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* where_clause);
  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();
  public:
  void unsafe_arena_set_allocated_where_clause(
      ::pg_query::Node* where_clause);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  // .pg_query.Node having_clause = 7 [json_name = "havingClause"];
  bool has_having_clause() const;
  private:
  bool _internal_has_having_clause() const;
  public:
  void clear_having_clause();
  const ::pg_query::Node& having_clause() const;
  ::pg_query::Node* release_having_clause();
  ::pg_query::Node* mutable_having_clause();
  void set_allocated_having_clause(::pg_query::Node* having_clause);
  private:
  const ::pg_query::Node& _internal_having_clause() const;
  ::pg_query::Node* _internal_mutable_having_clause();
  public:
  void unsafe_arena_set_allocated_having_clause(
      ::pg_query::Node* having_clause);
  ::pg_query::Node* unsafe_arena_release_having_clause();

  // .pg_query.Node limit_offset = 11 [json_name = "limitOffset"];
  bool has_limit_offset() const;
  private:
  bool _internal_has_limit_offset() const;
  public:
  void clear_limit_offset();
  const ::pg_query::Node& limit_offset() const;
  ::pg_query::Node* release_limit_offset();
  ::pg_query::Node* mutable_limit_offset();
  void set_allocated_limit_offset(::pg_query::Node* limit_offset);
  private:
  const ::pg_query::Node& _internal_limit_offset() const;
  ::pg_query::Node* _internal_mutable_limit_offset();
  public:
  void unsafe_arena_set_allocated_limit_offset(
      ::pg_query::Node* limit_offset);
  ::pg_query::Node* unsafe_arena_release_limit_offset();

  // .pg_query.Node limit_count = 12 [json_name = "limitCount"];
  bool has_limit_count() const;
  private:
  bool _internal_has_limit_count() const;
  public:
  void clear_limit_count();
  const ::pg_query::Node& limit_count() const;
  ::pg_query::Node* release_limit_count();
  ::pg_query::Node* mutable_limit_count();
  void set_allocated_limit_count(::pg_query::Node* limit_count);
  private:
  const ::pg_query::Node& _internal_limit_count() const;
  ::pg_query::Node* _internal_mutable_limit_count();
  public:
  void unsafe_arena_set_allocated_limit_count(
      ::pg_query::Node* limit_count);
  ::pg_query::Node* unsafe_arena_release_limit_count();

  // .pg_query.WithClause with_clause = 15 [json_name = "withClause"];
  bool has_with_clause() const;
  private:
  bool _internal_has_with_clause() const;
  public:
  void clear_with_clause();
  const ::pg_query::WithClause& with_clause() const;
  ::pg_query::WithClause* release_with_clause();
  ::pg_query::WithClause* mutable_with_clause();
  void set_allocated_with_clause(::pg_query::WithClause* with_clause);
  private:
  const ::pg_query::WithClause& _internal_with_clause() const;
  ::pg_query::WithClause* _internal_mutable_with_clause();
  public:
  void unsafe_arena_set_allocated_with_clause(
      ::pg_query::WithClause* with_clause);
  ::pg_query::WithClause* unsafe_arena_release_with_clause();

  // .pg_query.SelectStmt larg = 18 [json_name = "larg"];
  bool has_larg() const;
  private:
  bool _internal_has_larg() const;
  public:
  void clear_larg();
  const ::pg_query::SelectStmt& larg() const;
  ::pg_query::SelectStmt* release_larg();
  ::pg_query::SelectStmt* mutable_larg();
  void set_allocated_larg(::pg_query::SelectStmt* larg);
  private:
  const ::pg_query::SelectStmt& _internal_larg() const;
  ::pg_query::SelectStmt* _internal_mutable_larg();
  public:
  void unsafe_arena_set_allocated_larg(
      ::pg_query::SelectStmt* larg);
  ::pg_query::SelectStmt* unsafe_arena_release_larg();

  // .pg_query.SelectStmt rarg = 19 [json_name = "rarg"];
  bool has_rarg() const;
  private:
  bool _internal_has_rarg() const;
  public:
  void clear_rarg();
  const ::pg_query::SelectStmt& rarg() const;
  ::pg_query::SelectStmt* release_rarg();
  ::pg_query::SelectStmt* mutable_rarg();
  void set_allocated_rarg(::pg_query::SelectStmt* rarg);
  private:
  const ::pg_query::SelectStmt& _internal_rarg() const;
  ::pg_query::SelectStmt* _internal_mutable_rarg();
  public:
  void unsafe_arena_set_allocated_rarg(
      ::pg_query::SelectStmt* rarg);
  ::pg_query::SelectStmt* unsafe_arena_release_rarg();

  // .pg_query.LimitOption limit_option = 13 [json_name = "limitOption"];
  void clear_limit_option();
  ::pg_query::LimitOption limit_option() const;
  void set_limit_option(::pg_query::LimitOption value);
  private:
  ::pg_query::LimitOption _internal_limit_option() const;
  void _internal_set_limit_option(::pg_query::LimitOption value);
  public:

  // .pg_query.SetOperation op = 16 [json_name = "op"];
  void clear_op();
  ::pg_query::SetOperation op() const;
  void set_op(::pg_query::SetOperation value);
  private:
  ::pg_query::SetOperation _internal_op() const;
  void _internal_set_op(::pg_query::SetOperation value);
  public:

  // bool all = 17 [json_name = "all"];
  void clear_all();
  bool all() const;
  void set_all(bool value);
  private:
  bool _internal_all() const;
  void _internal_set_all(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.SelectStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > distinct_clause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > target_list_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > from_clause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > group_clause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > window_clause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > values_lists_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > sort_clause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > locking_clause_;
  ::pg_query::IntoClause* into_clause_;
  ::pg_query::Node* where_clause_;
  ::pg_query::Node* having_clause_;
  ::pg_query::Node* limit_offset_;
  ::pg_query::Node* limit_count_;
  ::pg_query::WithClause* with_clause_;
  ::pg_query::SelectStmt* larg_;
  ::pg_query::SelectStmt* rarg_;
  int limit_option_;
  int op_;
  bool all_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterTableStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTableStmt) */ {
 public:
  inline AlterTableStmt() : AlterTableStmt(nullptr) {}
  virtual ~AlterTableStmt();

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

  inline AlterTableStmt& operator=(const AlterTableStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterTableStmt& operator=(AlterTableStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterTableStmt& default_instance();

  static inline const AlterTableStmt* internal_default_instance() {
    return reinterpret_cast<const AlterTableStmt*>(
               &_AlterTableStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    69;

  friend void swap(AlterTableStmt& a, AlterTableStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterTableStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterTableStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterTableStmt* New() const final {
    return CreateMaybeMessage<AlterTableStmt>(nullptr);
  }

  AlterTableStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterTableStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterTableStmt& from);
  void MergeFrom(const AlterTableStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterTableStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterTableStmt";
  }
  protected:
  explicit AlterTableStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCmdsFieldNumber = 2,
    kRelationFieldNumber = 1,
    kRelkindFieldNumber = 3,
    kMissingOkFieldNumber = 4,
  };
  // repeated .pg_query.Node cmds = 2 [json_name = "cmds"];
  int cmds_size() const;
  private:
  int _internal_cmds_size() const;
  public:
  void clear_cmds();
  ::pg_query::Node* mutable_cmds(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_cmds();
  private:
  const ::pg_query::Node& _internal_cmds(int index) const;
  ::pg_query::Node* _internal_add_cmds();
  public:
  const ::pg_query::Node& cmds(int index) const;
  ::pg_query::Node* add_cmds();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      cmds() const;

  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.ObjectType relkind = 3 [json_name = "relkind"];
  void clear_relkind();
  ::pg_query::ObjectType relkind() const;
  void set_relkind(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_relkind() const;
  void _internal_set_relkind(::pg_query::ObjectType value);
  public:

  // bool missing_ok = 4 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterTableStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > cmds_;
  ::pg_query::RangeVar* relation_;
  int relkind_;
  bool missing_ok_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterTableCmd PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTableCmd) */ {
 public:
  inline AlterTableCmd() : AlterTableCmd(nullptr) {}
  virtual ~AlterTableCmd();

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

  inline AlterTableCmd& operator=(const AlterTableCmd& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterTableCmd& operator=(AlterTableCmd&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterTableCmd& default_instance();

  static inline const AlterTableCmd* internal_default_instance() {
    return reinterpret_cast<const AlterTableCmd*>(
               &_AlterTableCmd_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    70;

  friend void swap(AlterTableCmd& a, AlterTableCmd& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterTableCmd* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterTableCmd* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterTableCmd* New() const final {
    return CreateMaybeMessage<AlterTableCmd>(nullptr);
  }

  AlterTableCmd* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterTableCmd>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterTableCmd& from);
  void MergeFrom(const AlterTableCmd& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterTableCmd* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterTableCmd";
  }
  protected:
  explicit AlterTableCmd(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNameFieldNumber = 2,
    kNewownerFieldNumber = 4,
    kDefFieldNumber = 5,
    kSubtypeFieldNumber = 1,
    kNumFieldNumber = 3,
    kBehaviorFieldNumber = 6,
    kMissingOkFieldNumber = 7,
  };
  // string name = 2 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .pg_query.RoleSpec newowner = 4 [json_name = "newowner"];
  bool has_newowner() const;
  private:
  bool _internal_has_newowner() const;
  public:
  void clear_newowner();
  const ::pg_query::RoleSpec& newowner() const;
  ::pg_query::RoleSpec* release_newowner();
  ::pg_query::RoleSpec* mutable_newowner();
  void set_allocated_newowner(::pg_query::RoleSpec* newowner);
  private:
  const ::pg_query::RoleSpec& _internal_newowner() const;
  ::pg_query::RoleSpec* _internal_mutable_newowner();
  public:
  void unsafe_arena_set_allocated_newowner(
      ::pg_query::RoleSpec* newowner);
  ::pg_query::RoleSpec* unsafe_arena_release_newowner();

  // .pg_query.Node def = 5 [json_name = "def"];
  bool has_def() const;
  private:
  bool _internal_has_def() const;
  public:
  void clear_def();
  const ::pg_query::Node& def() const;
  ::pg_query::Node* release_def();
  ::pg_query::Node* mutable_def();
  void set_allocated_def(::pg_query::Node* def);
  private:
  const ::pg_query::Node& _internal_def() const;
  ::pg_query::Node* _internal_mutable_def();
  public:
  void unsafe_arena_set_allocated_def(
      ::pg_query::Node* def);
  ::pg_query::Node* unsafe_arena_release_def();

  // .pg_query.AlterTableType subtype = 1 [json_name = "subtype"];
  void clear_subtype();
  ::pg_query::AlterTableType subtype() const;
  void set_subtype(::pg_query::AlterTableType value);
  private:
  ::pg_query::AlterTableType _internal_subtype() const;
  void _internal_set_subtype(::pg_query::AlterTableType value);
  public:

  // int32 num = 3 [json_name = "num"];
  void clear_num();
  ::PROTOBUF_NAMESPACE_ID::int32 num() const;
  void set_num(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_num() const;
  void _internal_set_num(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // .pg_query.DropBehavior behavior = 6 [json_name = "behavior"];
  void clear_behavior();
  ::pg_query::DropBehavior behavior() const;
  void set_behavior(::pg_query::DropBehavior value);
  private:
  ::pg_query::DropBehavior _internal_behavior() const;
  void _internal_set_behavior(::pg_query::DropBehavior value);
  public:

  // bool missing_ok = 7 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterTableCmd)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::pg_query::RoleSpec* newowner_;
  ::pg_query::Node* def_;
  int subtype_;
  ::PROTOBUF_NAMESPACE_ID::int32 num_;
  int behavior_;
  bool missing_ok_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterDomainStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDomainStmt) */ {
 public:
  inline AlterDomainStmt() : AlterDomainStmt(nullptr) {}
  virtual ~AlterDomainStmt();

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

  inline AlterDomainStmt& operator=(const AlterDomainStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterDomainStmt& operator=(AlterDomainStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterDomainStmt& default_instance();

  static inline const AlterDomainStmt* internal_default_instance() {
    return reinterpret_cast<const AlterDomainStmt*>(
               &_AlterDomainStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    71;

  friend void swap(AlterDomainStmt& a, AlterDomainStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterDomainStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterDomainStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterDomainStmt* New() const final {
    return CreateMaybeMessage<AlterDomainStmt>(nullptr);
  }

  AlterDomainStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterDomainStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterDomainStmt& from);
  void MergeFrom(const AlterDomainStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterDomainStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterDomainStmt";
  }
  protected:
  explicit AlterDomainStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTypeNameFieldNumber = 2,
    kSubtypeFieldNumber = 1,
    kNameFieldNumber = 3,
    kDefFieldNumber = 4,
    kBehaviorFieldNumber = 5,
    kMissingOkFieldNumber = 6,
  };
  // repeated .pg_query.Node type_name = 2 [json_name = "typeName"];
  int type_name_size() const;
  private:
  int _internal_type_name_size() const;
  public:
  void clear_type_name();
  ::pg_query::Node* mutable_type_name(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_type_name();
  private:
  const ::pg_query::Node& _internal_type_name(int index) const;
  ::pg_query::Node* _internal_add_type_name();
  public:
  const ::pg_query::Node& type_name(int index) const;
  ::pg_query::Node* add_type_name();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      type_name() const;

  // string subtype = 1 [json_name = "subtype"];
  void clear_subtype();
  const std::string& subtype() const;
  void set_subtype(const std::string& value);
  void set_subtype(std::string&& value);
  void set_subtype(const char* value);
  void set_subtype(const char* value, size_t size);
  std::string* mutable_subtype();
  std::string* release_subtype();
  void set_allocated_subtype(std::string* subtype);
  private:
  const std::string& _internal_subtype() const;
  void _internal_set_subtype(const std::string& value);
  std::string* _internal_mutable_subtype();
  public:

  // string name = 3 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .pg_query.Node def = 4 [json_name = "def"];
  bool has_def() const;
  private:
  bool _internal_has_def() const;
  public:
  void clear_def();
  const ::pg_query::Node& def() const;
  ::pg_query::Node* release_def();
  ::pg_query::Node* mutable_def();
  void set_allocated_def(::pg_query::Node* def);
  private:
  const ::pg_query::Node& _internal_def() const;
  ::pg_query::Node* _internal_mutable_def();
  public:
  void unsafe_arena_set_allocated_def(
      ::pg_query::Node* def);
  ::pg_query::Node* unsafe_arena_release_def();

  // .pg_query.DropBehavior behavior = 5 [json_name = "behavior"];
  void clear_behavior();
  ::pg_query::DropBehavior behavior() const;
  void set_behavior(::pg_query::DropBehavior value);
  private:
  ::pg_query::DropBehavior _internal_behavior() const;
  void _internal_set_behavior(::pg_query::DropBehavior value);
  public:

  // bool missing_ok = 6 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterDomainStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > type_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subtype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::pg_query::Node* def_;
  int behavior_;
  bool missing_ok_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class SetOperationStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SetOperationStmt) */ {
 public:
  inline SetOperationStmt() : SetOperationStmt(nullptr) {}
  virtual ~SetOperationStmt();

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

  inline SetOperationStmt& operator=(const SetOperationStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline SetOperationStmt& operator=(SetOperationStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SetOperationStmt& default_instance();

  static inline const SetOperationStmt* internal_default_instance() {
    return reinterpret_cast<const SetOperationStmt*>(
               &_SetOperationStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    72;

  friend void swap(SetOperationStmt& a, SetOperationStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(SetOperationStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SetOperationStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SetOperationStmt* New() const final {
    return CreateMaybeMessage<SetOperationStmt>(nullptr);
  }

  SetOperationStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SetOperationStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SetOperationStmt& from);
  void MergeFrom(const SetOperationStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SetOperationStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.SetOperationStmt";
  }
  protected:
  explicit SetOperationStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kColTypesFieldNumber = 5,
    kColTypmodsFieldNumber = 6,
    kColCollationsFieldNumber = 7,
    kGroupClausesFieldNumber = 8,
    kLargFieldNumber = 3,
    kRargFieldNumber = 4,
    kOpFieldNumber = 1,
    kAllFieldNumber = 2,
  };
  // repeated .pg_query.Node col_types = 5 [json_name = "colTypes"];
  int col_types_size() const;
  private:
  int _internal_col_types_size() const;
  public:
  void clear_col_types();
  ::pg_query::Node* mutable_col_types(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_col_types();
  private:
  const ::pg_query::Node& _internal_col_types(int index) const;
  ::pg_query::Node* _internal_add_col_types();
  public:
  const ::pg_query::Node& col_types(int index) const;
  ::pg_query::Node* add_col_types();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      col_types() const;

  // repeated .pg_query.Node col_typmods = 6 [json_name = "colTypmods"];
  int col_typmods_size() const;
  private:
  int _internal_col_typmods_size() const;
  public:
  void clear_col_typmods();
  ::pg_query::Node* mutable_col_typmods(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_col_typmods();
  private:
  const ::pg_query::Node& _internal_col_typmods(int index) const;
  ::pg_query::Node* _internal_add_col_typmods();
  public:
  const ::pg_query::Node& col_typmods(int index) const;
  ::pg_query::Node* add_col_typmods();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      col_typmods() const;

  // repeated .pg_query.Node col_collations = 7 [json_name = "colCollations"];
  int col_collations_size() const;
  private:
  int _internal_col_collations_size() const;
  public:
  void clear_col_collations();
  ::pg_query::Node* mutable_col_collations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_col_collations();
  private:
  const ::pg_query::Node& _internal_col_collations(int index) const;
  ::pg_query::Node* _internal_add_col_collations();
  public:
  const ::pg_query::Node& col_collations(int index) const;
  ::pg_query::Node* add_col_collations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      col_collations() const;

  // repeated .pg_query.Node group_clauses = 8 [json_name = "groupClauses"];
  int group_clauses_size() const;
  private:
  int _internal_group_clauses_size() const;
  public:
  void clear_group_clauses();
  ::pg_query::Node* mutable_group_clauses(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_group_clauses();
  private:
  const ::pg_query::Node& _internal_group_clauses(int index) const;
  ::pg_query::Node* _internal_add_group_clauses();
  public:
  const ::pg_query::Node& group_clauses(int index) const;
  ::pg_query::Node* add_group_clauses();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      group_clauses() const;

  // .pg_query.Node larg = 3 [json_name = "larg"];
  bool has_larg() const;
  private:
  bool _internal_has_larg() const;
  public:
  void clear_larg();
  const ::pg_query::Node& larg() const;
  ::pg_query::Node* release_larg();
  ::pg_query::Node* mutable_larg();
  void set_allocated_larg(::pg_query::Node* larg);
  private:
  const ::pg_query::Node& _internal_larg() const;
  ::pg_query::Node* _internal_mutable_larg();
  public:
  void unsafe_arena_set_allocated_larg(
      ::pg_query::Node* larg);
  ::pg_query::Node* unsafe_arena_release_larg();

  // .pg_query.Node rarg = 4 [json_name = "rarg"];
  bool has_rarg() const;
  private:
  bool _internal_has_rarg() const;
  public:
  void clear_rarg();
  const ::pg_query::Node& rarg() const;
  ::pg_query::Node* release_rarg();
  ::pg_query::Node* mutable_rarg();
  void set_allocated_rarg(::pg_query::Node* rarg);
  private:
  const ::pg_query::Node& _internal_rarg() const;
  ::pg_query::Node* _internal_mutable_rarg();
  public:
  void unsafe_arena_set_allocated_rarg(
      ::pg_query::Node* rarg);
  ::pg_query::Node* unsafe_arena_release_rarg();

  // .pg_query.SetOperation op = 1 [json_name = "op"];
  void clear_op();
  ::pg_query::SetOperation op() const;
  void set_op(::pg_query::SetOperation value);
  private:
  ::pg_query::SetOperation _internal_op() const;
  void _internal_set_op(::pg_query::SetOperation value);
  public:

  // bool all = 2 [json_name = "all"];
  void clear_all();
  bool all() const;
  void set_all(bool value);
  private:
  bool _internal_all() const;
  void _internal_set_all(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.SetOperationStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > col_types_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > col_typmods_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > col_collations_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > group_clauses_;
  ::pg_query::Node* larg_;
  ::pg_query::Node* rarg_;
  int op_;
  bool all_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class GrantStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.GrantStmt) */ {
 public:
  inline GrantStmt() : GrantStmt(nullptr) {}
  virtual ~GrantStmt();

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

  inline GrantStmt& operator=(const GrantStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrantStmt& operator=(GrantStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GrantStmt& default_instance();

  static inline const GrantStmt* internal_default_instance() {
    return reinterpret_cast<const GrantStmt*>(
               &_GrantStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    73;

  friend void swap(GrantStmt& a, GrantStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(GrantStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrantStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline GrantStmt* New() const final {
    return CreateMaybeMessage<GrantStmt>(nullptr);
  }

  GrantStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GrantStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GrantStmt& from);
  void MergeFrom(const GrantStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GrantStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.GrantStmt";
  }
  protected:
  explicit GrantStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kObjectsFieldNumber = 4,
    kPrivilegesFieldNumber = 5,
    kGranteesFieldNumber = 6,
    kTargtypeFieldNumber = 2,
    kObjtypeFieldNumber = 3,
    kIsGrantFieldNumber = 1,
    kGrantOptionFieldNumber = 7,
    kBehaviorFieldNumber = 8,
  };
  // repeated .pg_query.Node objects = 4 [json_name = "objects"];
  int objects_size() const;
  private:
  int _internal_objects_size() const;
  public:
  void clear_objects();
  ::pg_query::Node* mutable_objects(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_objects();
  private:
  const ::pg_query::Node& _internal_objects(int index) const;
  ::pg_query::Node* _internal_add_objects();
  public:
  const ::pg_query::Node& objects(int index) const;
  ::pg_query::Node* add_objects();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      objects() const;

  // repeated .pg_query.Node privileges = 5 [json_name = "privileges"];
  int privileges_size() const;
  private:
  int _internal_privileges_size() const;
  public:
  void clear_privileges();
  ::pg_query::Node* mutable_privileges(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_privileges();
  private:
  const ::pg_query::Node& _internal_privileges(int index) const;
  ::pg_query::Node* _internal_add_privileges();
  public:
  const ::pg_query::Node& privileges(int index) const;
  ::pg_query::Node* add_privileges();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      privileges() const;

  // repeated .pg_query.Node grantees = 6 [json_name = "grantees"];
  int grantees_size() const;
  private:
  int _internal_grantees_size() const;
  public:
  void clear_grantees();
  ::pg_query::Node* mutable_grantees(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_grantees();
  private:
  const ::pg_query::Node& _internal_grantees(int index) const;
  ::pg_query::Node* _internal_add_grantees();
  public:
  const ::pg_query::Node& grantees(int index) const;
  ::pg_query::Node* add_grantees();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      grantees() const;

  // .pg_query.GrantTargetType targtype = 2 [json_name = "targtype"];
  void clear_targtype();
  ::pg_query::GrantTargetType targtype() const;
  void set_targtype(::pg_query::GrantTargetType value);
  private:
  ::pg_query::GrantTargetType _internal_targtype() const;
  void _internal_set_targtype(::pg_query::GrantTargetType value);
  public:

  // .pg_query.ObjectType objtype = 3 [json_name = "objtype"];
  void clear_objtype();
  ::pg_query::ObjectType objtype() const;
  void set_objtype(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_objtype() const;
  void _internal_set_objtype(::pg_query::ObjectType value);
  public:

  // bool is_grant = 1 [json_name = "is_grant"];
  void clear_is_grant();
  bool is_grant() const;
  void set_is_grant(bool value);
  private:
  bool _internal_is_grant() const;
  void _internal_set_is_grant(bool value);
  public:

  // bool grant_option = 7 [json_name = "grant_option"];
  void clear_grant_option();
  bool grant_option() const;
  void set_grant_option(bool value);
  private:
  bool _internal_grant_option() const;
  void _internal_set_grant_option(bool value);
  public:

  // .pg_query.DropBehavior behavior = 8 [json_name = "behavior"];
  void clear_behavior();
  ::pg_query::DropBehavior behavior() const;
  void set_behavior(::pg_query::DropBehavior value);
  private:
  ::pg_query::DropBehavior _internal_behavior() const;
  void _internal_set_behavior(::pg_query::DropBehavior value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.GrantStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > objects_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > privileges_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > grantees_;
  int targtype_;
  int objtype_;
  bool is_grant_;
  bool grant_option_;
  int behavior_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class GrantRoleStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.GrantRoleStmt) */ {
 public:
  inline GrantRoleStmt() : GrantRoleStmt(nullptr) {}
  virtual ~GrantRoleStmt();

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

  inline GrantRoleStmt& operator=(const GrantRoleStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrantRoleStmt& operator=(GrantRoleStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GrantRoleStmt& default_instance();

  static inline const GrantRoleStmt* internal_default_instance() {
    return reinterpret_cast<const GrantRoleStmt*>(
               &_GrantRoleStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    74;

  friend void swap(GrantRoleStmt& a, GrantRoleStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(GrantRoleStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrantRoleStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline GrantRoleStmt* New() const final {
    return CreateMaybeMessage<GrantRoleStmt>(nullptr);
  }

  GrantRoleStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GrantRoleStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GrantRoleStmt& from);
  void MergeFrom(const GrantRoleStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GrantRoleStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.GrantRoleStmt";
  }
  protected:
  explicit GrantRoleStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kGrantedRolesFieldNumber = 1,
    kGranteeRolesFieldNumber = 2,
    kGrantorFieldNumber = 5,
    kIsGrantFieldNumber = 3,
    kAdminOptFieldNumber = 4,
    kBehaviorFieldNumber = 6,
  };
  // repeated .pg_query.Node granted_roles = 1 [json_name = "granted_roles"];
  int granted_roles_size() const;
  private:
  int _internal_granted_roles_size() const;
  public:
  void clear_granted_roles();
  ::pg_query::Node* mutable_granted_roles(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_granted_roles();
  private:
  const ::pg_query::Node& _internal_granted_roles(int index) const;
  ::pg_query::Node* _internal_add_granted_roles();
  public:
  const ::pg_query::Node& granted_roles(int index) const;
  ::pg_query::Node* add_granted_roles();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      granted_roles() const;

  // repeated .pg_query.Node grantee_roles = 2 [json_name = "grantee_roles"];
  int grantee_roles_size() const;
  private:
  int _internal_grantee_roles_size() const;
  public:
  void clear_grantee_roles();
  ::pg_query::Node* mutable_grantee_roles(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_grantee_roles();
  private:
  const ::pg_query::Node& _internal_grantee_roles(int index) const;
  ::pg_query::Node* _internal_add_grantee_roles();
  public:
  const ::pg_query::Node& grantee_roles(int index) const;
  ::pg_query::Node* add_grantee_roles();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      grantee_roles() const;

  // .pg_query.RoleSpec grantor = 5 [json_name = "grantor"];
  bool has_grantor() const;
  private:
  bool _internal_has_grantor() const;
  public:
  void clear_grantor();
  const ::pg_query::RoleSpec& grantor() const;
  ::pg_query::RoleSpec* release_grantor();
  ::pg_query::RoleSpec* mutable_grantor();
  void set_allocated_grantor(::pg_query::RoleSpec* grantor);
  private:
  const ::pg_query::RoleSpec& _internal_grantor() const;
  ::pg_query::RoleSpec* _internal_mutable_grantor();
  public:
  void unsafe_arena_set_allocated_grantor(
      ::pg_query::RoleSpec* grantor);
  ::pg_query::RoleSpec* unsafe_arena_release_grantor();

  // bool is_grant = 3 [json_name = "is_grant"];
  void clear_is_grant();
  bool is_grant() const;
  void set_is_grant(bool value);
  private:
  bool _internal_is_grant() const;
  void _internal_set_is_grant(bool value);
  public:

  // bool admin_opt = 4 [json_name = "admin_opt"];
  void clear_admin_opt();
  bool admin_opt() const;
  void set_admin_opt(bool value);
  private:
  bool _internal_admin_opt() const;
  void _internal_set_admin_opt(bool value);
  public:

  // .pg_query.DropBehavior behavior = 6 [json_name = "behavior"];
  void clear_behavior();
  ::pg_query::DropBehavior behavior() const;
  void set_behavior(::pg_query::DropBehavior value);
  private:
  ::pg_query::DropBehavior _internal_behavior() const;
  void _internal_set_behavior(::pg_query::DropBehavior value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.GrantRoleStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > granted_roles_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > grantee_roles_;
  ::pg_query::RoleSpec* grantor_;
  bool is_grant_;
  bool admin_opt_;
  int behavior_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterDefaultPrivilegesStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDefaultPrivilegesStmt) */ {
 public:
  inline AlterDefaultPrivilegesStmt() : AlterDefaultPrivilegesStmt(nullptr) {}
  virtual ~AlterDefaultPrivilegesStmt();

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

  inline AlterDefaultPrivilegesStmt& operator=(const AlterDefaultPrivilegesStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterDefaultPrivilegesStmt& operator=(AlterDefaultPrivilegesStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterDefaultPrivilegesStmt& default_instance();

  static inline const AlterDefaultPrivilegesStmt* internal_default_instance() {
    return reinterpret_cast<const AlterDefaultPrivilegesStmt*>(
               &_AlterDefaultPrivilegesStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    75;

  friend void swap(AlterDefaultPrivilegesStmt& a, AlterDefaultPrivilegesStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterDefaultPrivilegesStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterDefaultPrivilegesStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterDefaultPrivilegesStmt* New() const final {
    return CreateMaybeMessage<AlterDefaultPrivilegesStmt>(nullptr);
  }

  AlterDefaultPrivilegesStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterDefaultPrivilegesStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterDefaultPrivilegesStmt& from);
  void MergeFrom(const AlterDefaultPrivilegesStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterDefaultPrivilegesStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterDefaultPrivilegesStmt";
  }
  protected:
  explicit AlterDefaultPrivilegesStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 1,
    kActionFieldNumber = 2,
  };
  // repeated .pg_query.Node options = 1 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // .pg_query.GrantStmt action = 2 [json_name = "action"];
  bool has_action() const;
  private:
  bool _internal_has_action() const;
  public:
  void clear_action();
  const ::pg_query::GrantStmt& action() const;
  ::pg_query::GrantStmt* release_action();
  ::pg_query::GrantStmt* mutable_action();
  void set_allocated_action(::pg_query::GrantStmt* action);
  private:
  const ::pg_query::GrantStmt& _internal_action() const;
  ::pg_query::GrantStmt* _internal_mutable_action();
  public:
  void unsafe_arena_set_allocated_action(
      ::pg_query::GrantStmt* action);
  ::pg_query::GrantStmt* unsafe_arena_release_action();

  // @@protoc_insertion_point(class_scope:pg_query.AlterDefaultPrivilegesStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::pg_query::GrantStmt* action_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ClosePortalStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ClosePortalStmt) */ {
 public:
  inline ClosePortalStmt() : ClosePortalStmt(nullptr) {}
  virtual ~ClosePortalStmt();

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

  inline ClosePortalStmt& operator=(const ClosePortalStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline ClosePortalStmt& operator=(ClosePortalStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ClosePortalStmt& default_instance();

  static inline const ClosePortalStmt* internal_default_instance() {
    return reinterpret_cast<const ClosePortalStmt*>(
               &_ClosePortalStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    76;

  friend void swap(ClosePortalStmt& a, ClosePortalStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ClosePortalStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ClosePortalStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ClosePortalStmt* New() const final {
    return CreateMaybeMessage<ClosePortalStmt>(nullptr);
  }

  ClosePortalStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClosePortalStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ClosePortalStmt& from);
  void MergeFrom(const ClosePortalStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ClosePortalStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ClosePortalStmt";
  }
  protected:
  explicit ClosePortalStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPortalnameFieldNumber = 1,
  };
  // string portalname = 1 [json_name = "portalname"];
  void clear_portalname();
  const std::string& portalname() const;
  void set_portalname(const std::string& value);
  void set_portalname(std::string&& value);
  void set_portalname(const char* value);
  void set_portalname(const char* value, size_t size);
  std::string* mutable_portalname();
  std::string* release_portalname();
  void set_allocated_portalname(std::string* portalname);
  private:
  const std::string& _internal_portalname() const;
  void _internal_set_portalname(const std::string& value);
  std::string* _internal_mutable_portalname();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ClosePortalStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr portalname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ClusterStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ClusterStmt) */ {
 public:
  inline ClusterStmt() : ClusterStmt(nullptr) {}
  virtual ~ClusterStmt();

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

  inline ClusterStmt& operator=(const ClusterStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline ClusterStmt& operator=(ClusterStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ClusterStmt& default_instance();

  static inline const ClusterStmt* internal_default_instance() {
    return reinterpret_cast<const ClusterStmt*>(
               &_ClusterStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    77;

  friend void swap(ClusterStmt& a, ClusterStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ClusterStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ClusterStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ClusterStmt* New() const final {
    return CreateMaybeMessage<ClusterStmt>(nullptr);
  }

  ClusterStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClusterStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ClusterStmt& from);
  void MergeFrom(const ClusterStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ClusterStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ClusterStmt";
  }
  protected:
  explicit ClusterStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIndexnameFieldNumber = 2,
    kRelationFieldNumber = 1,
    kOptionsFieldNumber = 3,
  };
  // string indexname = 2 [json_name = "indexname"];
  void clear_indexname();
  const std::string& indexname() const;
  void set_indexname(const std::string& value);
  void set_indexname(std::string&& value);
  void set_indexname(const char* value);
  void set_indexname(const char* value, size_t size);
  std::string* mutable_indexname();
  std::string* release_indexname();
  void set_allocated_indexname(std::string* indexname);
  private:
  const std::string& _internal_indexname() const;
  void _internal_set_indexname(const std::string& value);
  std::string* _internal_mutable_indexname();
  public:

  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // int32 options = 3 [json_name = "options"];
  void clear_options();
  ::PROTOBUF_NAMESPACE_ID::int32 options() const;
  void set_options(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_options() const;
  void _internal_set_options(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ClusterStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr indexname_;
  ::pg_query::RangeVar* relation_;
  ::PROTOBUF_NAMESPACE_ID::int32 options_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CopyStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CopyStmt) */ {
 public:
  inline CopyStmt() : CopyStmt(nullptr) {}
  virtual ~CopyStmt();

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

  inline CopyStmt& operator=(const CopyStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CopyStmt& operator=(CopyStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CopyStmt& default_instance();

  static inline const CopyStmt* internal_default_instance() {
    return reinterpret_cast<const CopyStmt*>(
               &_CopyStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    78;

  friend void swap(CopyStmt& a, CopyStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CopyStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CopyStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CopyStmt* New() const final {
    return CreateMaybeMessage<CopyStmt>(nullptr);
  }

  CopyStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CopyStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CopyStmt& from);
  void MergeFrom(const CopyStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CopyStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CopyStmt";
  }
  protected:
  explicit CopyStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAttlistFieldNumber = 3,
    kOptionsFieldNumber = 7,
    kFilenameFieldNumber = 6,
    kRelationFieldNumber = 1,
    kQueryFieldNumber = 2,
    kWhereClauseFieldNumber = 8,
    kIsFromFieldNumber = 4,
    kIsProgramFieldNumber = 5,
  };
  // repeated .pg_query.Node attlist = 3 [json_name = "attlist"];
  int attlist_size() const;
  private:
  int _internal_attlist_size() const;
  public:
  void clear_attlist();
  ::pg_query::Node* mutable_attlist(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_attlist();
  private:
  const ::pg_query::Node& _internal_attlist(int index) const;
  ::pg_query::Node* _internal_add_attlist();
  public:
  const ::pg_query::Node& attlist(int index) const;
  ::pg_query::Node* add_attlist();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      attlist() const;

  // repeated .pg_query.Node options = 7 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string filename = 6 [json_name = "filename"];
  void clear_filename();
  const std::string& filename() const;
  void set_filename(const std::string& value);
  void set_filename(std::string&& value);
  void set_filename(const char* value);
  void set_filename(const char* value, size_t size);
  std::string* mutable_filename();
  std::string* release_filename();
  void set_allocated_filename(std::string* filename);
  private:
  const std::string& _internal_filename() const;
  void _internal_set_filename(const std::string& value);
  std::string* _internal_mutable_filename();
  public:

  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.Node query = 2 [json_name = "query"];
  bool has_query() const;
  private:
  bool _internal_has_query() const;
  public:
  void clear_query();
  const ::pg_query::Node& query() const;
  ::pg_query::Node* release_query();
  ::pg_query::Node* mutable_query();
  void set_allocated_query(::pg_query::Node* query);
  private:
  const ::pg_query::Node& _internal_query() const;
  ::pg_query::Node* _internal_mutable_query();
  public:
  void unsafe_arena_set_allocated_query(
      ::pg_query::Node* query);
  ::pg_query::Node* unsafe_arena_release_query();

  // .pg_query.Node where_clause = 8 [json_name = "whereClause"];
  bool has_where_clause() const;
  private:
  bool _internal_has_where_clause() const;
  public:
  void clear_where_clause();
  const ::pg_query::Node& where_clause() const;
  ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* where_clause);
  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();
  public:
  void unsafe_arena_set_allocated_where_clause(
      ::pg_query::Node* where_clause);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  // bool is_from = 4 [json_name = "is_from"];
  void clear_is_from();
  bool is_from() const;
  void set_is_from(bool value);
  private:
  bool _internal_is_from() const;
  void _internal_set_is_from(bool value);
  public:

  // bool is_program = 5 [json_name = "is_program"];
  void clear_is_program();
  bool is_program() const;
  void set_is_program(bool value);
  private:
  bool _internal_is_program() const;
  void _internal_set_is_program(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CopyStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > attlist_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_;
  ::pg_query::RangeVar* relation_;
  ::pg_query::Node* query_;
  ::pg_query::Node* where_clause_;
  bool is_from_;
  bool is_program_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateStmt) */ {
 public:
  inline CreateStmt() : CreateStmt(nullptr) {}
  virtual ~CreateStmt();

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

  inline CreateStmt& operator=(const CreateStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateStmt& operator=(CreateStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateStmt& default_instance();

  static inline const CreateStmt* internal_default_instance() {
    return reinterpret_cast<const CreateStmt*>(
               &_CreateStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    79;

  friend void swap(CreateStmt& a, CreateStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateStmt* New() const final {
    return CreateMaybeMessage<CreateStmt>(nullptr);
  }

  CreateStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateStmt& from);
  void MergeFrom(const CreateStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateStmt";
  }
  protected:
  explicit CreateStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTableEltsFieldNumber = 2,
    kInhRelationsFieldNumber = 3,
    kConstraintsFieldNumber = 7,
    kOptionsFieldNumber = 8,
    kTablespacenameFieldNumber = 10,
    kAccessMethodFieldNumber = 11,
    kRelationFieldNumber = 1,
    kPartboundFieldNumber = 4,
    kPartspecFieldNumber = 5,
    kOfTypenameFieldNumber = 6,
    kOncommitFieldNumber = 9,
    kIfNotExistsFieldNumber = 12,
  };
  // repeated .pg_query.Node table_elts = 2 [json_name = "tableElts"];
  int table_elts_size() const;
  private:
  int _internal_table_elts_size() const;
  public:
  void clear_table_elts();
  ::pg_query::Node* mutable_table_elts(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_table_elts();
  private:
  const ::pg_query::Node& _internal_table_elts(int index) const;
  ::pg_query::Node* _internal_add_table_elts();
  public:
  const ::pg_query::Node& table_elts(int index) const;
  ::pg_query::Node* add_table_elts();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      table_elts() const;

  // repeated .pg_query.Node inh_relations = 3 [json_name = "inhRelations"];
  int inh_relations_size() const;
  private:
  int _internal_inh_relations_size() const;
  public:
  void clear_inh_relations();
  ::pg_query::Node* mutable_inh_relations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_inh_relations();
  private:
  const ::pg_query::Node& _internal_inh_relations(int index) const;
  ::pg_query::Node* _internal_add_inh_relations();
  public:
  const ::pg_query::Node& inh_relations(int index) const;
  ::pg_query::Node* add_inh_relations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      inh_relations() const;

  // repeated .pg_query.Node constraints = 7 [json_name = "constraints"];
  int constraints_size() const;
  private:
  int _internal_constraints_size() const;
  public:
  void clear_constraints();
  ::pg_query::Node* mutable_constraints(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_constraints();
  private:
  const ::pg_query::Node& _internal_constraints(int index) const;
  ::pg_query::Node* _internal_add_constraints();
  public:
  const ::pg_query::Node& constraints(int index) const;
  ::pg_query::Node* add_constraints();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      constraints() const;

  // repeated .pg_query.Node options = 8 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string tablespacename = 10 [json_name = "tablespacename"];
  void clear_tablespacename();
  const std::string& tablespacename() const;
  void set_tablespacename(const std::string& value);
  void set_tablespacename(std::string&& value);
  void set_tablespacename(const char* value);
  void set_tablespacename(const char* value, size_t size);
  std::string* mutable_tablespacename();
  std::string* release_tablespacename();
  void set_allocated_tablespacename(std::string* tablespacename);
  private:
  const std::string& _internal_tablespacename() const;
  void _internal_set_tablespacename(const std::string& value);
  std::string* _internal_mutable_tablespacename();
  public:

  // string access_method = 11 [json_name = "accessMethod"];
  void clear_access_method();
  const std::string& access_method() const;
  void set_access_method(const std::string& value);
  void set_access_method(std::string&& value);
  void set_access_method(const char* value);
  void set_access_method(const char* value, size_t size);
  std::string* mutable_access_method();
  std::string* release_access_method();
  void set_allocated_access_method(std::string* access_method);
  private:
  const std::string& _internal_access_method() const;
  void _internal_set_access_method(const std::string& value);
  std::string* _internal_mutable_access_method();
  public:

  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.PartitionBoundSpec partbound = 4 [json_name = "partbound"];
  bool has_partbound() const;
  private:
  bool _internal_has_partbound() const;
  public:
  void clear_partbound();
  const ::pg_query::PartitionBoundSpec& partbound() const;
  ::pg_query::PartitionBoundSpec* release_partbound();
  ::pg_query::PartitionBoundSpec* mutable_partbound();
  void set_allocated_partbound(::pg_query::PartitionBoundSpec* partbound);
  private:
  const ::pg_query::PartitionBoundSpec& _internal_partbound() const;
  ::pg_query::PartitionBoundSpec* _internal_mutable_partbound();
  public:
  void unsafe_arena_set_allocated_partbound(
      ::pg_query::PartitionBoundSpec* partbound);
  ::pg_query::PartitionBoundSpec* unsafe_arena_release_partbound();

  // .pg_query.PartitionSpec partspec = 5 [json_name = "partspec"];
  bool has_partspec() const;
  private:
  bool _internal_has_partspec() const;
  public:
  void clear_partspec();
  const ::pg_query::PartitionSpec& partspec() const;
  ::pg_query::PartitionSpec* release_partspec();
  ::pg_query::PartitionSpec* mutable_partspec();
  void set_allocated_partspec(::pg_query::PartitionSpec* partspec);
  private:
  const ::pg_query::PartitionSpec& _internal_partspec() const;
  ::pg_query::PartitionSpec* _internal_mutable_partspec();
  public:
  void unsafe_arena_set_allocated_partspec(
      ::pg_query::PartitionSpec* partspec);
  ::pg_query::PartitionSpec* unsafe_arena_release_partspec();

  // .pg_query.TypeName of_typename = 6 [json_name = "ofTypename"];
  bool has_of_typename() const;
  private:
  bool _internal_has_of_typename() const;
  public:
  void clear_of_typename();
  const ::pg_query::TypeName& of_typename() const;
  ::pg_query::TypeName* release_of_typename();
  ::pg_query::TypeName* mutable_of_typename();
  void set_allocated_of_typename(::pg_query::TypeName* of_typename);
  private:
  const ::pg_query::TypeName& _internal_of_typename() const;
  ::pg_query::TypeName* _internal_mutable_of_typename();
  public:
  void unsafe_arena_set_allocated_of_typename(
      ::pg_query::TypeName* of_typename);
  ::pg_query::TypeName* unsafe_arena_release_of_typename();

  // .pg_query.OnCommitAction oncommit = 9 [json_name = "oncommit"];
  void clear_oncommit();
  ::pg_query::OnCommitAction oncommit() const;
  void set_oncommit(::pg_query::OnCommitAction value);
  private:
  ::pg_query::OnCommitAction _internal_oncommit() const;
  void _internal_set_oncommit(::pg_query::OnCommitAction value);
  public:

  // bool if_not_exists = 12 [json_name = "if_not_exists"];
  void clear_if_not_exists();
  bool if_not_exists() const;
  void set_if_not_exists(bool value);
  private:
  bool _internal_if_not_exists() const;
  void _internal_set_if_not_exists(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > table_elts_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > inh_relations_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > constraints_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tablespacename_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr access_method_;
  ::pg_query::RangeVar* relation_;
  ::pg_query::PartitionBoundSpec* partbound_;
  ::pg_query::PartitionSpec* partspec_;
  ::pg_query::TypeName* of_typename_;
  int oncommit_;
  bool if_not_exists_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class DefineStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DefineStmt) */ {
 public:
  inline DefineStmt() : DefineStmt(nullptr) {}
  virtual ~DefineStmt();

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

  inline DefineStmt& operator=(const DefineStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline DefineStmt& operator=(DefineStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DefineStmt& default_instance();

  static inline const DefineStmt* internal_default_instance() {
    return reinterpret_cast<const DefineStmt*>(
               &_DefineStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    80;

  friend void swap(DefineStmt& a, DefineStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(DefineStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DefineStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline DefineStmt* New() const final {
    return CreateMaybeMessage<DefineStmt>(nullptr);
  }

  DefineStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DefineStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DefineStmt& from);
  void MergeFrom(const DefineStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DefineStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DefineStmt";
  }
  protected:
  explicit DefineStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDefnamesFieldNumber = 3,
    kArgsFieldNumber = 4,
    kDefinitionFieldNumber = 5,
    kKindFieldNumber = 1,
    kOldstyleFieldNumber = 2,
    kIfNotExistsFieldNumber = 6,
    kReplaceFieldNumber = 7,
  };
  // repeated .pg_query.Node defnames = 3 [json_name = "defnames"];
  int defnames_size() const;
  private:
  int _internal_defnames_size() const;
  public:
  void clear_defnames();
  ::pg_query::Node* mutable_defnames(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_defnames();
  private:
  const ::pg_query::Node& _internal_defnames(int index) const;
  ::pg_query::Node* _internal_add_defnames();
  public:
  const ::pg_query::Node& defnames(int index) const;
  ::pg_query::Node* add_defnames();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      defnames() const;

  // repeated .pg_query.Node args = 4 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // repeated .pg_query.Node definition = 5 [json_name = "definition"];
  int definition_size() const;
  private:
  int _internal_definition_size() const;
  public:
  void clear_definition();
  ::pg_query::Node* mutable_definition(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_definition();
  private:
  const ::pg_query::Node& _internal_definition(int index) const;
  ::pg_query::Node* _internal_add_definition();
  public:
  const ::pg_query::Node& definition(int index) const;
  ::pg_query::Node* add_definition();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      definition() const;

  // .pg_query.ObjectType kind = 1 [json_name = "kind"];
  void clear_kind();
  ::pg_query::ObjectType kind() const;
  void set_kind(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_kind() const;
  void _internal_set_kind(::pg_query::ObjectType value);
  public:

  // bool oldstyle = 2 [json_name = "oldstyle"];
  void clear_oldstyle();
  bool oldstyle() const;
  void set_oldstyle(bool value);
  private:
  bool _internal_oldstyle() const;
  void _internal_set_oldstyle(bool value);
  public:

  // bool if_not_exists = 6 [json_name = "if_not_exists"];
  void clear_if_not_exists();
  bool if_not_exists() const;
  void set_if_not_exists(bool value);
  private:
  bool _internal_if_not_exists() const;
  void _internal_set_if_not_exists(bool value);
  public:

  // bool replace = 7 [json_name = "replace"];
  void clear_replace();
  bool replace() const;
  void set_replace(bool value);
  private:
  bool _internal_replace() const;
  void _internal_set_replace(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.DefineStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > defnames_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > definition_;
  int kind_;
  bool oldstyle_;
  bool if_not_exists_;
  bool replace_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class DropStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropStmt) */ {
 public:
  inline DropStmt() : DropStmt(nullptr) {}
  virtual ~DropStmt();

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

  inline DropStmt& operator=(const DropStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline DropStmt& operator=(DropStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DropStmt& default_instance();

  static inline const DropStmt* internal_default_instance() {
    return reinterpret_cast<const DropStmt*>(
               &_DropStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    81;

  friend void swap(DropStmt& a, DropStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(DropStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DropStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline DropStmt* New() const final {
    return CreateMaybeMessage<DropStmt>(nullptr);
  }

  DropStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DropStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DropStmt& from);
  void MergeFrom(const DropStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DropStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DropStmt";
  }
  protected:
  explicit DropStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kObjectsFieldNumber = 1,
    kRemoveTypeFieldNumber = 2,
    kBehaviorFieldNumber = 3,
    kMissingOkFieldNumber = 4,
    kConcurrentFieldNumber = 5,
  };
  // repeated .pg_query.Node objects = 1 [json_name = "objects"];
  int objects_size() const;
  private:
  int _internal_objects_size() const;
  public:
  void clear_objects();
  ::pg_query::Node* mutable_objects(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_objects();
  private:
  const ::pg_query::Node& _internal_objects(int index) const;
  ::pg_query::Node* _internal_add_objects();
  public:
  const ::pg_query::Node& objects(int index) const;
  ::pg_query::Node* add_objects();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      objects() const;

  // .pg_query.ObjectType remove_type = 2 [json_name = "removeType"];
  void clear_remove_type();
  ::pg_query::ObjectType remove_type() const;
  void set_remove_type(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_remove_type() const;
  void _internal_set_remove_type(::pg_query::ObjectType value);
  public:

  // .pg_query.DropBehavior behavior = 3 [json_name = "behavior"];
  void clear_behavior();
  ::pg_query::DropBehavior behavior() const;
  void set_behavior(::pg_query::DropBehavior value);
  private:
  ::pg_query::DropBehavior _internal_behavior() const;
  void _internal_set_behavior(::pg_query::DropBehavior value);
  public:

  // bool missing_ok = 4 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // bool concurrent = 5 [json_name = "concurrent"];
  void clear_concurrent();
  bool concurrent() const;
  void set_concurrent(bool value);
  private:
  bool _internal_concurrent() const;
  void _internal_set_concurrent(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.DropStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > objects_;
  int remove_type_;
  int behavior_;
  bool missing_ok_;
  bool concurrent_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class TruncateStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TruncateStmt) */ {
 public:
  inline TruncateStmt() : TruncateStmt(nullptr) {}
  virtual ~TruncateStmt();

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

  inline TruncateStmt& operator=(const TruncateStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline TruncateStmt& operator=(TruncateStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TruncateStmt& default_instance();

  static inline const TruncateStmt* internal_default_instance() {
    return reinterpret_cast<const TruncateStmt*>(
               &_TruncateStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    82;

  friend void swap(TruncateStmt& a, TruncateStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(TruncateStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TruncateStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline TruncateStmt* New() const final {
    return CreateMaybeMessage<TruncateStmt>(nullptr);
  }

  TruncateStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TruncateStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TruncateStmt& from);
  void MergeFrom(const TruncateStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TruncateStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.TruncateStmt";
  }
  protected:
  explicit TruncateStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRelationsFieldNumber = 1,
    kRestartSeqsFieldNumber = 2,
    kBehaviorFieldNumber = 3,
  };
  // repeated .pg_query.Node relations = 1 [json_name = "relations"];
  int relations_size() const;
  private:
  int _internal_relations_size() const;
  public:
  void clear_relations();
  ::pg_query::Node* mutable_relations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_relations();
  private:
  const ::pg_query::Node& _internal_relations(int index) const;
  ::pg_query::Node* _internal_add_relations();
  public:
  const ::pg_query::Node& relations(int index) const;
  ::pg_query::Node* add_relations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      relations() const;

  // bool restart_seqs = 2 [json_name = "restart_seqs"];
  void clear_restart_seqs();
  bool restart_seqs() const;
  void set_restart_seqs(bool value);
  private:
  bool _internal_restart_seqs() const;
  void _internal_set_restart_seqs(bool value);
  public:

  // .pg_query.DropBehavior behavior = 3 [json_name = "behavior"];
  void clear_behavior();
  ::pg_query::DropBehavior behavior() const;
  void set_behavior(::pg_query::DropBehavior value);
  private:
  ::pg_query::DropBehavior _internal_behavior() const;
  void _internal_set_behavior(::pg_query::DropBehavior value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.TruncateStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > relations_;
  bool restart_seqs_;
  int behavior_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CommentStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CommentStmt) */ {
 public:
  inline CommentStmt() : CommentStmt(nullptr) {}
  virtual ~CommentStmt();

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

  inline CommentStmt& operator=(const CommentStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CommentStmt& operator=(CommentStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CommentStmt& default_instance();

  static inline const CommentStmt* internal_default_instance() {
    return reinterpret_cast<const CommentStmt*>(
               &_CommentStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    83;

  friend void swap(CommentStmt& a, CommentStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CommentStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CommentStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CommentStmt* New() const final {
    return CreateMaybeMessage<CommentStmt>(nullptr);
  }

  CommentStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CommentStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CommentStmt& from);
  void MergeFrom(const CommentStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CommentStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CommentStmt";
  }
  protected:
  explicit CommentStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCommentFieldNumber = 3,
    kObjectFieldNumber = 2,
    kObjtypeFieldNumber = 1,
  };
  // string comment = 3 [json_name = "comment"];
  void clear_comment();
  const std::string& comment() const;
  void set_comment(const std::string& value);
  void set_comment(std::string&& value);
  void set_comment(const char* value);
  void set_comment(const char* value, size_t size);
  std::string* mutable_comment();
  std::string* release_comment();
  void set_allocated_comment(std::string* comment);
  private:
  const std::string& _internal_comment() const;
  void _internal_set_comment(const std::string& value);
  std::string* _internal_mutable_comment();
  public:

  // .pg_query.Node object = 2 [json_name = "object"];
  bool has_object() const;
  private:
  bool _internal_has_object() const;
  public:
  void clear_object();
  const ::pg_query::Node& object() const;
  ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* object);
  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();
  public:
  void unsafe_arena_set_allocated_object(
      ::pg_query::Node* object);
  ::pg_query::Node* unsafe_arena_release_object();

  // .pg_query.ObjectType objtype = 1 [json_name = "objtype"];
  void clear_objtype();
  ::pg_query::ObjectType objtype() const;
  void set_objtype(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_objtype() const;
  void _internal_set_objtype(::pg_query::ObjectType value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CommentStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_;
  ::pg_query::Node* object_;
  int objtype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class FetchStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FetchStmt) */ {
 public:
  inline FetchStmt() : FetchStmt(nullptr) {}
  virtual ~FetchStmt();

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

  inline FetchStmt& operator=(const FetchStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline FetchStmt& operator=(FetchStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const FetchStmt& default_instance();

  static inline const FetchStmt* internal_default_instance() {
    return reinterpret_cast<const FetchStmt*>(
               &_FetchStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    84;

  friend void swap(FetchStmt& a, FetchStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(FetchStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FetchStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline FetchStmt* New() const final {
    return CreateMaybeMessage<FetchStmt>(nullptr);
  }

  FetchStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FetchStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const FetchStmt& from);
  void MergeFrom(const FetchStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FetchStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.FetchStmt";
  }
  protected:
  explicit FetchStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPortalnameFieldNumber = 3,
    kHowManyFieldNumber = 2,
    kDirectionFieldNumber = 1,
    kIsmoveFieldNumber = 4,
  };
  // string portalname = 3 [json_name = "portalname"];
  void clear_portalname();
  const std::string& portalname() const;
  void set_portalname(const std::string& value);
  void set_portalname(std::string&& value);
  void set_portalname(const char* value);
  void set_portalname(const char* value, size_t size);
  std::string* mutable_portalname();
  std::string* release_portalname();
  void set_allocated_portalname(std::string* portalname);
  private:
  const std::string& _internal_portalname() const;
  void _internal_set_portalname(const std::string& value);
  std::string* _internal_mutable_portalname();
  public:

  // int64 how_many = 2 [json_name = "howMany"];
  void clear_how_many();
  ::PROTOBUF_NAMESPACE_ID::int64 how_many() const;
  void set_how_many(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_how_many() const;
  void _internal_set_how_many(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // .pg_query.FetchDirection direction = 1 [json_name = "direction"];
  void clear_direction();
  ::pg_query::FetchDirection direction() const;
  void set_direction(::pg_query::FetchDirection value);
  private:
  ::pg_query::FetchDirection _internal_direction() const;
  void _internal_set_direction(::pg_query::FetchDirection value);
  public:

  // bool ismove = 4 [json_name = "ismove"];
  void clear_ismove();
  bool ismove() const;
  void set_ismove(bool value);
  private:
  bool _internal_ismove() const;
  void _internal_set_ismove(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.FetchStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr portalname_;
  ::PROTOBUF_NAMESPACE_ID::int64 how_many_;
  int direction_;
  bool ismove_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class IndexStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.IndexStmt) */ {
 public:
  inline IndexStmt() : IndexStmt(nullptr) {}
  virtual ~IndexStmt();

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

  inline IndexStmt& operator=(const IndexStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline IndexStmt& operator=(IndexStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const IndexStmt& default_instance();

  static inline const IndexStmt* internal_default_instance() {
    return reinterpret_cast<const IndexStmt*>(
               &_IndexStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    85;

  friend void swap(IndexStmt& a, IndexStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(IndexStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IndexStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline IndexStmt* New() const final {
    return CreateMaybeMessage<IndexStmt>(nullptr);
  }

  IndexStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<IndexStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const IndexStmt& from);
  void MergeFrom(const IndexStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(IndexStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.IndexStmt";
  }
  protected:
  explicit IndexStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIndexParamsFieldNumber = 5,
    kIndexIncludingParamsFieldNumber = 6,
    kOptionsFieldNumber = 7,
    kExcludeOpNamesFieldNumber = 9,
    kIdxnameFieldNumber = 1,
    kAccessMethodFieldNumber = 3,
    kTableSpaceFieldNumber = 4,
    kIdxcommentFieldNumber = 10,
    kRelationFieldNumber = 2,
    kWhereClauseFieldNumber = 8,
    kIndexOidFieldNumber = 11,
    kOldNodeFieldNumber = 12,
    kOldCreateSubidFieldNumber = 13,
    kOldFirstRelfilenodeSubidFieldNumber = 14,
    kUniqueFieldNumber = 15,
    kPrimaryFieldNumber = 16,
    kIsconstraintFieldNumber = 17,
    kDeferrableFieldNumber = 18,
    kInitdeferredFieldNumber = 19,
    kTransformedFieldNumber = 20,
    kConcurrentFieldNumber = 21,
    kIfNotExistsFieldNumber = 22,
    kResetDefaultTblspcFieldNumber = 23,
  };
  // repeated .pg_query.Node index_params = 5 [json_name = "indexParams"];
  int index_params_size() const;
  private:
  int _internal_index_params_size() const;
  public:
  void clear_index_params();
  ::pg_query::Node* mutable_index_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_index_params();
  private:
  const ::pg_query::Node& _internal_index_params(int index) const;
  ::pg_query::Node* _internal_add_index_params();
  public:
  const ::pg_query::Node& index_params(int index) const;
  ::pg_query::Node* add_index_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      index_params() const;

  // repeated .pg_query.Node index_including_params = 6 [json_name = "indexIncludingParams"];
  int index_including_params_size() const;
  private:
  int _internal_index_including_params_size() const;
  public:
  void clear_index_including_params();
  ::pg_query::Node* mutable_index_including_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_index_including_params();
  private:
  const ::pg_query::Node& _internal_index_including_params(int index) const;
  ::pg_query::Node* _internal_add_index_including_params();
  public:
  const ::pg_query::Node& index_including_params(int index) const;
  ::pg_query::Node* add_index_including_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      index_including_params() const;

  // repeated .pg_query.Node options = 7 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // repeated .pg_query.Node exclude_op_names = 9 [json_name = "excludeOpNames"];
  int exclude_op_names_size() const;
  private:
  int _internal_exclude_op_names_size() const;
  public:
  void clear_exclude_op_names();
  ::pg_query::Node* mutable_exclude_op_names(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_exclude_op_names();
  private:
  const ::pg_query::Node& _internal_exclude_op_names(int index) const;
  ::pg_query::Node* _internal_add_exclude_op_names();
  public:
  const ::pg_query::Node& exclude_op_names(int index) const;
  ::pg_query::Node* add_exclude_op_names();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      exclude_op_names() const;

  // string idxname = 1 [json_name = "idxname"];
  void clear_idxname();
  const std::string& idxname() const;
  void set_idxname(const std::string& value);
  void set_idxname(std::string&& value);
  void set_idxname(const char* value);
  void set_idxname(const char* value, size_t size);
  std::string* mutable_idxname();
  std::string* release_idxname();
  void set_allocated_idxname(std::string* idxname);
  private:
  const std::string& _internal_idxname() const;
  void _internal_set_idxname(const std::string& value);
  std::string* _internal_mutable_idxname();
  public:

  // string access_method = 3 [json_name = "accessMethod"];
  void clear_access_method();
  const std::string& access_method() const;
  void set_access_method(const std::string& value);
  void set_access_method(std::string&& value);
  void set_access_method(const char* value);
  void set_access_method(const char* value, size_t size);
  std::string* mutable_access_method();
  std::string* release_access_method();
  void set_allocated_access_method(std::string* access_method);
  private:
  const std::string& _internal_access_method() const;
  void _internal_set_access_method(const std::string& value);
  std::string* _internal_mutable_access_method();
  public:

  // string table_space = 4 [json_name = "tableSpace"];
  void clear_table_space();
  const std::string& table_space() const;
  void set_table_space(const std::string& value);
  void set_table_space(std::string&& value);
  void set_table_space(const char* value);
  void set_table_space(const char* value, size_t size);
  std::string* mutable_table_space();
  std::string* release_table_space();
  void set_allocated_table_space(std::string* table_space);
  private:
  const std::string& _internal_table_space() const;
  void _internal_set_table_space(const std::string& value);
  std::string* _internal_mutable_table_space();
  public:

  // string idxcomment = 10 [json_name = "idxcomment"];
  void clear_idxcomment();
  const std::string& idxcomment() const;
  void set_idxcomment(const std::string& value);
  void set_idxcomment(std::string&& value);
  void set_idxcomment(const char* value);
  void set_idxcomment(const char* value, size_t size);
  std::string* mutable_idxcomment();
  std::string* release_idxcomment();
  void set_allocated_idxcomment(std::string* idxcomment);
  private:
  const std::string& _internal_idxcomment() const;
  void _internal_set_idxcomment(const std::string& value);
  std::string* _internal_mutable_idxcomment();
  public:

  // .pg_query.RangeVar relation = 2 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.Node where_clause = 8 [json_name = "whereClause"];
  bool has_where_clause() const;
  private:
  bool _internal_has_where_clause() const;
  public:
  void clear_where_clause();
  const ::pg_query::Node& where_clause() const;
  ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* where_clause);
  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();
  public:
  void unsafe_arena_set_allocated_where_clause(
      ::pg_query::Node* where_clause);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  // uint32 index_oid = 11 [json_name = "indexOid"];
  void clear_index_oid();
  ::PROTOBUF_NAMESPACE_ID::uint32 index_oid() const;
  void set_index_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_index_oid() const;
  void _internal_set_index_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 old_node = 12 [json_name = "oldNode"];
  void clear_old_node();
  ::PROTOBUF_NAMESPACE_ID::uint32 old_node() const;
  void set_old_node(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_old_node() const;
  void _internal_set_old_node(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 old_create_subid = 13 [json_name = "oldCreateSubid"];
  void clear_old_create_subid();
  ::PROTOBUF_NAMESPACE_ID::uint32 old_create_subid() const;
  void set_old_create_subid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_old_create_subid() const;
  void _internal_set_old_create_subid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 old_first_relfilenode_subid = 14 [json_name = "oldFirstRelfilenodeSubid"];
  void clear_old_first_relfilenode_subid();
  ::PROTOBUF_NAMESPACE_ID::uint32 old_first_relfilenode_subid() const;
  void set_old_first_relfilenode_subid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_old_first_relfilenode_subid() const;
  void _internal_set_old_first_relfilenode_subid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool unique = 15 [json_name = "unique"];
  void clear_unique();
  bool unique() const;
  void set_unique(bool value);
  private:
  bool _internal_unique() const;
  void _internal_set_unique(bool value);
  public:

  // bool primary = 16 [json_name = "primary"];
  void clear_primary();
  bool primary() const;
  void set_primary(bool value);
  private:
  bool _internal_primary() const;
  void _internal_set_primary(bool value);
  public:

  // bool isconstraint = 17 [json_name = "isconstraint"];
  void clear_isconstraint();
  bool isconstraint() const;
  void set_isconstraint(bool value);
  private:
  bool _internal_isconstraint() const;
  void _internal_set_isconstraint(bool value);
  public:

  // bool deferrable = 18 [json_name = "deferrable"];
  void clear_deferrable();
  bool deferrable() const;
  void set_deferrable(bool value);
  private:
  bool _internal_deferrable() const;
  void _internal_set_deferrable(bool value);
  public:

  // bool initdeferred = 19 [json_name = "initdeferred"];
  void clear_initdeferred();
  bool initdeferred() const;
  void set_initdeferred(bool value);
  private:
  bool _internal_initdeferred() const;
  void _internal_set_initdeferred(bool value);
  public:

  // bool transformed = 20 [json_name = "transformed"];
  void clear_transformed();
  bool transformed() const;
  void set_transformed(bool value);
  private:
  bool _internal_transformed() const;
  void _internal_set_transformed(bool value);
  public:

  // bool concurrent = 21 [json_name = "concurrent"];
  void clear_concurrent();
  bool concurrent() const;
  void set_concurrent(bool value);
  private:
  bool _internal_concurrent() const;
  void _internal_set_concurrent(bool value);
  public:

  // bool if_not_exists = 22 [json_name = "if_not_exists"];
  void clear_if_not_exists();
  bool if_not_exists() const;
  void set_if_not_exists(bool value);
  private:
  bool _internal_if_not_exists() const;
  void _internal_set_if_not_exists(bool value);
  public:

  // bool reset_default_tblspc = 23 [json_name = "reset_default_tblspc"];
  void clear_reset_default_tblspc();
  bool reset_default_tblspc() const;
  void set_reset_default_tblspc(bool value);
  private:
  bool _internal_reset_default_tblspc() const;
  void _internal_set_reset_default_tblspc(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.IndexStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > index_params_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > index_including_params_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > exclude_op_names_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr idxname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr access_method_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_space_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr idxcomment_;
  ::pg_query::RangeVar* relation_;
  ::pg_query::Node* where_clause_;
  ::PROTOBUF_NAMESPACE_ID::uint32 index_oid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 old_node_;
  ::PROTOBUF_NAMESPACE_ID::uint32 old_create_subid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 old_first_relfilenode_subid_;
  bool unique_;
  bool primary_;
  bool isconstraint_;
  bool deferrable_;
  bool initdeferred_;
  bool transformed_;
  bool concurrent_;
  bool if_not_exists_;
  bool reset_default_tblspc_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateFunctionStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateFunctionStmt) */ {
 public:
  inline CreateFunctionStmt() : CreateFunctionStmt(nullptr) {}
  virtual ~CreateFunctionStmt();

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

  inline CreateFunctionStmt& operator=(const CreateFunctionStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateFunctionStmt& operator=(CreateFunctionStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateFunctionStmt& default_instance();

  static inline const CreateFunctionStmt* internal_default_instance() {
    return reinterpret_cast<const CreateFunctionStmt*>(
               &_CreateFunctionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    86;

  friend void swap(CreateFunctionStmt& a, CreateFunctionStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateFunctionStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateFunctionStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateFunctionStmt* New() const final {
    return CreateMaybeMessage<CreateFunctionStmt>(nullptr);
  }

  CreateFunctionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateFunctionStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateFunctionStmt& from);
  void MergeFrom(const CreateFunctionStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateFunctionStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateFunctionStmt";
  }
  protected:
  explicit CreateFunctionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kFuncnameFieldNumber = 3,
    kParametersFieldNumber = 4,
    kOptionsFieldNumber = 6,
    kReturnTypeFieldNumber = 5,
    kIsProcedureFieldNumber = 1,
    kReplaceFieldNumber = 2,
  };
  // repeated .pg_query.Node funcname = 3 [json_name = "funcname"];
  int funcname_size() const;
  private:
  int _internal_funcname_size() const;
  public:
  void clear_funcname();
  ::pg_query::Node* mutable_funcname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_funcname();
  private:
  const ::pg_query::Node& _internal_funcname(int index) const;
  ::pg_query::Node* _internal_add_funcname();
  public:
  const ::pg_query::Node& funcname(int index) const;
  ::pg_query::Node* add_funcname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      funcname() const;

  // repeated .pg_query.Node parameters = 4 [json_name = "parameters"];
  int parameters_size() const;
  private:
  int _internal_parameters_size() const;
  public:
  void clear_parameters();
  ::pg_query::Node* mutable_parameters(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_parameters();
  private:
  const ::pg_query::Node& _internal_parameters(int index) const;
  ::pg_query::Node* _internal_add_parameters();
  public:
  const ::pg_query::Node& parameters(int index) const;
  ::pg_query::Node* add_parameters();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      parameters() const;

  // repeated .pg_query.Node options = 6 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // .pg_query.TypeName return_type = 5 [json_name = "returnType"];
  bool has_return_type() const;
  private:
  bool _internal_has_return_type() const;
  public:
  void clear_return_type();
  const ::pg_query::TypeName& return_type() const;
  ::pg_query::TypeName* release_return_type();
  ::pg_query::TypeName* mutable_return_type();
  void set_allocated_return_type(::pg_query::TypeName* return_type);
  private:
  const ::pg_query::TypeName& _internal_return_type() const;
  ::pg_query::TypeName* _internal_mutable_return_type();
  public:
  void unsafe_arena_set_allocated_return_type(
      ::pg_query::TypeName* return_type);
  ::pg_query::TypeName* unsafe_arena_release_return_type();

  // bool is_procedure = 1 [json_name = "is_procedure"];
  void clear_is_procedure();
  bool is_procedure() const;
  void set_is_procedure(bool value);
  private:
  bool _internal_is_procedure() const;
  void _internal_set_is_procedure(bool value);
  public:

  // bool replace = 2 [json_name = "replace"];
  void clear_replace();
  bool replace() const;
  void set_replace(bool value);
  private:
  bool _internal_replace() const;
  void _internal_set_replace(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateFunctionStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funcname_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > parameters_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::pg_query::TypeName* return_type_;
  bool is_procedure_;
  bool replace_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterFunctionStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterFunctionStmt) */ {
 public:
  inline AlterFunctionStmt() : AlterFunctionStmt(nullptr) {}
  virtual ~AlterFunctionStmt();

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

  inline AlterFunctionStmt& operator=(const AlterFunctionStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterFunctionStmt& operator=(AlterFunctionStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterFunctionStmt& default_instance();

  static inline const AlterFunctionStmt* internal_default_instance() {
    return reinterpret_cast<const AlterFunctionStmt*>(
               &_AlterFunctionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    87;

  friend void swap(AlterFunctionStmt& a, AlterFunctionStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterFunctionStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterFunctionStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterFunctionStmt* New() const final {
    return CreateMaybeMessage<AlterFunctionStmt>(nullptr);
  }

  AlterFunctionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterFunctionStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterFunctionStmt& from);
  void MergeFrom(const AlterFunctionStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterFunctionStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterFunctionStmt";
  }
  protected:
  explicit AlterFunctionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kActionsFieldNumber = 3,
    kFuncFieldNumber = 2,
    kObjtypeFieldNumber = 1,
  };
  // repeated .pg_query.Node actions = 3 [json_name = "actions"];
  int actions_size() const;
  private:
  int _internal_actions_size() const;
  public:
  void clear_actions();
  ::pg_query::Node* mutable_actions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_actions();
  private:
  const ::pg_query::Node& _internal_actions(int index) const;
  ::pg_query::Node* _internal_add_actions();
  public:
  const ::pg_query::Node& actions(int index) const;
  ::pg_query::Node* add_actions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      actions() const;

  // .pg_query.ObjectWithArgs func = 2 [json_name = "func"];
  bool has_func() const;
  private:
  bool _internal_has_func() const;
  public:
  void clear_func();
  const ::pg_query::ObjectWithArgs& func() const;
  ::pg_query::ObjectWithArgs* release_func();
  ::pg_query::ObjectWithArgs* mutable_func();
  void set_allocated_func(::pg_query::ObjectWithArgs* func);
  private:
  const ::pg_query::ObjectWithArgs& _internal_func() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_func();
  public:
  void unsafe_arena_set_allocated_func(
      ::pg_query::ObjectWithArgs* func);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_func();

  // .pg_query.ObjectType objtype = 1 [json_name = "objtype"];
  void clear_objtype();
  ::pg_query::ObjectType objtype() const;
  void set_objtype(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_objtype() const;
  void _internal_set_objtype(::pg_query::ObjectType value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterFunctionStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > actions_;
  ::pg_query::ObjectWithArgs* func_;
  int objtype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class DoStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DoStmt) */ {
 public:
  inline DoStmt() : DoStmt(nullptr) {}
  virtual ~DoStmt();

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

  inline DoStmt& operator=(const DoStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline DoStmt& operator=(DoStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DoStmt& default_instance();

  static inline const DoStmt* internal_default_instance() {
    return reinterpret_cast<const DoStmt*>(
               &_DoStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    88;

  friend void swap(DoStmt& a, DoStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(DoStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DoStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline DoStmt* New() const final {
    return CreateMaybeMessage<DoStmt>(nullptr);
  }

  DoStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DoStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DoStmt& from);
  void MergeFrom(const DoStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DoStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DoStmt";
  }
  protected:
  explicit DoStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 1,
  };
  // repeated .pg_query.Node args = 1 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // @@protoc_insertion_point(class_scope:pg_query.DoStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RenameStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RenameStmt) */ {
 public:
  inline RenameStmt() : RenameStmt(nullptr) {}
  virtual ~RenameStmt();

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

  inline RenameStmt& operator=(const RenameStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline RenameStmt& operator=(RenameStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RenameStmt& default_instance();

  static inline const RenameStmt* internal_default_instance() {
    return reinterpret_cast<const RenameStmt*>(
               &_RenameStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    89;

  friend void swap(RenameStmt& a, RenameStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(RenameStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RenameStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline RenameStmt* New() const final {
    return CreateMaybeMessage<RenameStmt>(nullptr);
  }

  RenameStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RenameStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RenameStmt& from);
  void MergeFrom(const RenameStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RenameStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RenameStmt";
  }
  protected:
  explicit RenameStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSubnameFieldNumber = 5,
    kNewnameFieldNumber = 6,
    kRelationFieldNumber = 3,
    kObjectFieldNumber = 4,
    kRenameTypeFieldNumber = 1,
    kRelationTypeFieldNumber = 2,
    kBehaviorFieldNumber = 7,
    kMissingOkFieldNumber = 8,
  };
  // string subname = 5 [json_name = "subname"];
  void clear_subname();
  const std::string& subname() const;
  void set_subname(const std::string& value);
  void set_subname(std::string&& value);
  void set_subname(const char* value);
  void set_subname(const char* value, size_t size);
  std::string* mutable_subname();
  std::string* release_subname();
  void set_allocated_subname(std::string* subname);
  private:
  const std::string& _internal_subname() const;
  void _internal_set_subname(const std::string& value);
  std::string* _internal_mutable_subname();
  public:

  // string newname = 6 [json_name = "newname"];
  void clear_newname();
  const std::string& newname() const;
  void set_newname(const std::string& value);
  void set_newname(std::string&& value);
  void set_newname(const char* value);
  void set_newname(const char* value, size_t size);
  std::string* mutable_newname();
  std::string* release_newname();
  void set_allocated_newname(std::string* newname);
  private:
  const std::string& _internal_newname() const;
  void _internal_set_newname(const std::string& value);
  std::string* _internal_mutable_newname();
  public:

  // .pg_query.RangeVar relation = 3 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.Node object = 4 [json_name = "object"];
  bool has_object() const;
  private:
  bool _internal_has_object() const;
  public:
  void clear_object();
  const ::pg_query::Node& object() const;
  ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* object);
  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();
  public:
  void unsafe_arena_set_allocated_object(
      ::pg_query::Node* object);
  ::pg_query::Node* unsafe_arena_release_object();

  // .pg_query.ObjectType rename_type = 1 [json_name = "renameType"];
  void clear_rename_type();
  ::pg_query::ObjectType rename_type() const;
  void set_rename_type(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_rename_type() const;
  void _internal_set_rename_type(::pg_query::ObjectType value);
  public:

  // .pg_query.ObjectType relation_type = 2 [json_name = "relationType"];
  void clear_relation_type();
  ::pg_query::ObjectType relation_type() const;
  void set_relation_type(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_relation_type() const;
  void _internal_set_relation_type(::pg_query::ObjectType value);
  public:

  // .pg_query.DropBehavior behavior = 7 [json_name = "behavior"];
  void clear_behavior();
  ::pg_query::DropBehavior behavior() const;
  void set_behavior(::pg_query::DropBehavior value);
  private:
  ::pg_query::DropBehavior _internal_behavior() const;
  void _internal_set_behavior(::pg_query::DropBehavior value);
  public:

  // bool missing_ok = 8 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RenameStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newname_;
  ::pg_query::RangeVar* relation_;
  ::pg_query::Node* object_;
  int rename_type_;
  int relation_type_;
  int behavior_;
  bool missing_ok_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RuleStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RuleStmt) */ {
 public:
  inline RuleStmt() : RuleStmt(nullptr) {}
  virtual ~RuleStmt();

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

  inline RuleStmt& operator=(const RuleStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline RuleStmt& operator=(RuleStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RuleStmt& default_instance();

  static inline const RuleStmt* internal_default_instance() {
    return reinterpret_cast<const RuleStmt*>(
               &_RuleStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    90;

  friend void swap(RuleStmt& a, RuleStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(RuleStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RuleStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline RuleStmt* New() const final {
    return CreateMaybeMessage<RuleStmt>(nullptr);
  }

  RuleStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RuleStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RuleStmt& from);
  void MergeFrom(const RuleStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RuleStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RuleStmt";
  }
  protected:
  explicit RuleStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kActionsFieldNumber = 6,
    kRulenameFieldNumber = 2,
    kRelationFieldNumber = 1,
    kWhereClauseFieldNumber = 3,
    kEventFieldNumber = 4,
    kInsteadFieldNumber = 5,
    kReplaceFieldNumber = 7,
  };
  // repeated .pg_query.Node actions = 6 [json_name = "actions"];
  int actions_size() const;
  private:
  int _internal_actions_size() const;
  public:
  void clear_actions();
  ::pg_query::Node* mutable_actions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_actions();
  private:
  const ::pg_query::Node& _internal_actions(int index) const;
  ::pg_query::Node* _internal_add_actions();
  public:
  const ::pg_query::Node& actions(int index) const;
  ::pg_query::Node* add_actions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      actions() const;

  // string rulename = 2 [json_name = "rulename"];
  void clear_rulename();
  const std::string& rulename() const;
  void set_rulename(const std::string& value);
  void set_rulename(std::string&& value);
  void set_rulename(const char* value);
  void set_rulename(const char* value, size_t size);
  std::string* mutable_rulename();
  std::string* release_rulename();
  void set_allocated_rulename(std::string* rulename);
  private:
  const std::string& _internal_rulename() const;
  void _internal_set_rulename(const std::string& value);
  std::string* _internal_mutable_rulename();
  public:

  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.Node where_clause = 3 [json_name = "whereClause"];
  bool has_where_clause() const;
  private:
  bool _internal_has_where_clause() const;
  public:
  void clear_where_clause();
  const ::pg_query::Node& where_clause() const;
  ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* where_clause);
  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();
  public:
  void unsafe_arena_set_allocated_where_clause(
      ::pg_query::Node* where_clause);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  // .pg_query.CmdType event = 4 [json_name = "event"];
  void clear_event();
  ::pg_query::CmdType event() const;
  void set_event(::pg_query::CmdType value);
  private:
  ::pg_query::CmdType _internal_event() const;
  void _internal_set_event(::pg_query::CmdType value);
  public:

  // bool instead = 5 [json_name = "instead"];
  void clear_instead();
  bool instead() const;
  void set_instead(bool value);
  private:
  bool _internal_instead() const;
  void _internal_set_instead(bool value);
  public:

  // bool replace = 7 [json_name = "replace"];
  void clear_replace();
  bool replace() const;
  void set_replace(bool value);
  private:
  bool _internal_replace() const;
  void _internal_set_replace(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RuleStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > actions_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rulename_;
  ::pg_query::RangeVar* relation_;
  ::pg_query::Node* where_clause_;
  int event_;
  bool instead_;
  bool replace_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class NotifyStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.NotifyStmt) */ {
 public:
  inline NotifyStmt() : NotifyStmt(nullptr) {}
  virtual ~NotifyStmt();

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

  inline NotifyStmt& operator=(const NotifyStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline NotifyStmt& operator=(NotifyStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const NotifyStmt& default_instance();

  static inline const NotifyStmt* internal_default_instance() {
    return reinterpret_cast<const NotifyStmt*>(
               &_NotifyStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    91;

  friend void swap(NotifyStmt& a, NotifyStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(NotifyStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NotifyStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline NotifyStmt* New() const final {
    return CreateMaybeMessage<NotifyStmt>(nullptr);
  }

  NotifyStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<NotifyStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const NotifyStmt& from);
  void MergeFrom(const NotifyStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NotifyStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.NotifyStmt";
  }
  protected:
  explicit NotifyStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kConditionnameFieldNumber = 1,
    kPayloadFieldNumber = 2,
  };
  // string conditionname = 1 [json_name = "conditionname"];
  void clear_conditionname();
  const std::string& conditionname() const;
  void set_conditionname(const std::string& value);
  void set_conditionname(std::string&& value);
  void set_conditionname(const char* value);
  void set_conditionname(const char* value, size_t size);
  std::string* mutable_conditionname();
  std::string* release_conditionname();
  void set_allocated_conditionname(std::string* conditionname);
  private:
  const std::string& _internal_conditionname() const;
  void _internal_set_conditionname(const std::string& value);
  std::string* _internal_mutable_conditionname();
  public:

  // string payload = 2 [json_name = "payload"];
  void clear_payload();
  const std::string& payload() const;
  void set_payload(const std::string& value);
  void set_payload(std::string&& value);
  void set_payload(const char* value);
  void set_payload(const char* value, size_t size);
  std::string* mutable_payload();
  std::string* release_payload();
  void set_allocated_payload(std::string* payload);
  private:
  const std::string& _internal_payload() const;
  void _internal_set_payload(const std::string& value);
  std::string* _internal_mutable_payload();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.NotifyStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conditionname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ListenStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ListenStmt) */ {
 public:
  inline ListenStmt() : ListenStmt(nullptr) {}
  virtual ~ListenStmt();

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

  inline ListenStmt& operator=(const ListenStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline ListenStmt& operator=(ListenStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ListenStmt& default_instance();

  static inline const ListenStmt* internal_default_instance() {
    return reinterpret_cast<const ListenStmt*>(
               &_ListenStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    92;

  friend void swap(ListenStmt& a, ListenStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ListenStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ListenStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ListenStmt* New() const final {
    return CreateMaybeMessage<ListenStmt>(nullptr);
  }

  ListenStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ListenStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ListenStmt& from);
  void MergeFrom(const ListenStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ListenStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ListenStmt";
  }
  protected:
  explicit ListenStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kConditionnameFieldNumber = 1,
  };
  // string conditionname = 1 [json_name = "conditionname"];
  void clear_conditionname();
  const std::string& conditionname() const;
  void set_conditionname(const std::string& value);
  void set_conditionname(std::string&& value);
  void set_conditionname(const char* value);
  void set_conditionname(const char* value, size_t size);
  std::string* mutable_conditionname();
  std::string* release_conditionname();
  void set_allocated_conditionname(std::string* conditionname);
  private:
  const std::string& _internal_conditionname() const;
  void _internal_set_conditionname(const std::string& value);
  std::string* _internal_mutable_conditionname();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ListenStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conditionname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class UnlistenStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.UnlistenStmt) */ {
 public:
  inline UnlistenStmt() : UnlistenStmt(nullptr) {}
  virtual ~UnlistenStmt();

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

  inline UnlistenStmt& operator=(const UnlistenStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline UnlistenStmt& operator=(UnlistenStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const UnlistenStmt& default_instance();

  static inline const UnlistenStmt* internal_default_instance() {
    return reinterpret_cast<const UnlistenStmt*>(
               &_UnlistenStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    93;

  friend void swap(UnlistenStmt& a, UnlistenStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(UnlistenStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(UnlistenStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline UnlistenStmt* New() const final {
    return CreateMaybeMessage<UnlistenStmt>(nullptr);
  }

  UnlistenStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<UnlistenStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const UnlistenStmt& from);
  void MergeFrom(const UnlistenStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(UnlistenStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.UnlistenStmt";
  }
  protected:
  explicit UnlistenStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kConditionnameFieldNumber = 1,
  };
  // string conditionname = 1 [json_name = "conditionname"];
  void clear_conditionname();
  const std::string& conditionname() const;
  void set_conditionname(const std::string& value);
  void set_conditionname(std::string&& value);
  void set_conditionname(const char* value);
  void set_conditionname(const char* value, size_t size);
  std::string* mutable_conditionname();
  std::string* release_conditionname();
  void set_allocated_conditionname(std::string* conditionname);
  private:
  const std::string& _internal_conditionname() const;
  void _internal_set_conditionname(const std::string& value);
  std::string* _internal_mutable_conditionname();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.UnlistenStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conditionname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class TransactionStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TransactionStmt) */ {
 public:
  inline TransactionStmt() : TransactionStmt(nullptr) {}
  virtual ~TransactionStmt();

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

  inline TransactionStmt& operator=(const TransactionStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline TransactionStmt& operator=(TransactionStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TransactionStmt& default_instance();

  static inline const TransactionStmt* internal_default_instance() {
    return reinterpret_cast<const TransactionStmt*>(
               &_TransactionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    94;

  friend void swap(TransactionStmt& a, TransactionStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(TransactionStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TransactionStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline TransactionStmt* New() const final {
    return CreateMaybeMessage<TransactionStmt>(nullptr);
  }

  TransactionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TransactionStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TransactionStmt& from);
  void MergeFrom(const TransactionStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TransactionStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.TransactionStmt";
  }
  protected:
  explicit TransactionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 2,
    kSavepointNameFieldNumber = 3,
    kGidFieldNumber = 4,
    kKindFieldNumber = 1,
    kChainFieldNumber = 5,
  };
  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string savepoint_name = 3 [json_name = "savepoint_name"];
  void clear_savepoint_name();
  const std::string& savepoint_name() const;
  void set_savepoint_name(const std::string& value);
  void set_savepoint_name(std::string&& value);
  void set_savepoint_name(const char* value);
  void set_savepoint_name(const char* value, size_t size);
  std::string* mutable_savepoint_name();
  std::string* release_savepoint_name();
  void set_allocated_savepoint_name(std::string* savepoint_name);
  private:
  const std::string& _internal_savepoint_name() const;
  void _internal_set_savepoint_name(const std::string& value);
  std::string* _internal_mutable_savepoint_name();
  public:

  // string gid = 4 [json_name = "gid"];
  void clear_gid();
  const std::string& gid() const;
  void set_gid(const std::string& value);
  void set_gid(std::string&& value);
  void set_gid(const char* value);
  void set_gid(const char* value, size_t size);
  std::string* mutable_gid();
  std::string* release_gid();
  void set_allocated_gid(std::string* gid);
  private:
  const std::string& _internal_gid() const;
  void _internal_set_gid(const std::string& value);
  std::string* _internal_mutable_gid();
  public:

  // .pg_query.TransactionStmtKind kind = 1 [json_name = "kind"];
  void clear_kind();
  ::pg_query::TransactionStmtKind kind() const;
  void set_kind(::pg_query::TransactionStmtKind value);
  private:
  ::pg_query::TransactionStmtKind _internal_kind() const;
  void _internal_set_kind(::pg_query::TransactionStmtKind value);
  public:

  // bool chain = 5 [json_name = "chain"];
  void clear_chain();
  bool chain() const;
  void set_chain(bool value);
  private:
  bool _internal_chain() const;
  void _internal_set_chain(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.TransactionStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr savepoint_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gid_;
  int kind_;
  bool chain_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ViewStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ViewStmt) */ {
 public:
  inline ViewStmt() : ViewStmt(nullptr) {}
  virtual ~ViewStmt();

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

  inline ViewStmt& operator=(const ViewStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline ViewStmt& operator=(ViewStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ViewStmt& default_instance();

  static inline const ViewStmt* internal_default_instance() {
    return reinterpret_cast<const ViewStmt*>(
               &_ViewStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    95;

  friend void swap(ViewStmt& a, ViewStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ViewStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ViewStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ViewStmt* New() const final {
    return CreateMaybeMessage<ViewStmt>(nullptr);
  }

  ViewStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ViewStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ViewStmt& from);
  void MergeFrom(const ViewStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ViewStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ViewStmt";
  }
  protected:
  explicit ViewStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAliasesFieldNumber = 2,
    kOptionsFieldNumber = 5,
    kViewFieldNumber = 1,
    kQueryFieldNumber = 3,
    kReplaceFieldNumber = 4,
    kWithCheckOptionFieldNumber = 6,
  };
  // repeated .pg_query.Node aliases = 2 [json_name = "aliases"];
  int aliases_size() const;
  private:
  int _internal_aliases_size() const;
  public:
  void clear_aliases();
  ::pg_query::Node* mutable_aliases(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_aliases();
  private:
  const ::pg_query::Node& _internal_aliases(int index) const;
  ::pg_query::Node* _internal_add_aliases();
  public:
  const ::pg_query::Node& aliases(int index) const;
  ::pg_query::Node* add_aliases();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      aliases() const;

  // repeated .pg_query.Node options = 5 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // .pg_query.RangeVar view = 1 [json_name = "view"];
  bool has_view() const;
  private:
  bool _internal_has_view() const;
  public:
  void clear_view();
  const ::pg_query::RangeVar& view() const;
  ::pg_query::RangeVar* release_view();
  ::pg_query::RangeVar* mutable_view();
  void set_allocated_view(::pg_query::RangeVar* view);
  private:
  const ::pg_query::RangeVar& _internal_view() const;
  ::pg_query::RangeVar* _internal_mutable_view();
  public:
  void unsafe_arena_set_allocated_view(
      ::pg_query::RangeVar* view);
  ::pg_query::RangeVar* unsafe_arena_release_view();

  // .pg_query.Node query = 3 [json_name = "query"];
  bool has_query() const;
  private:
  bool _internal_has_query() const;
  public:
  void clear_query();
  const ::pg_query::Node& query() const;
  ::pg_query::Node* release_query();
  ::pg_query::Node* mutable_query();
  void set_allocated_query(::pg_query::Node* query);
  private:
  const ::pg_query::Node& _internal_query() const;
  ::pg_query::Node* _internal_mutable_query();
  public:
  void unsafe_arena_set_allocated_query(
      ::pg_query::Node* query);
  ::pg_query::Node* unsafe_arena_release_query();

  // bool replace = 4 [json_name = "replace"];
  void clear_replace();
  bool replace() const;
  void set_replace(bool value);
  private:
  bool _internal_replace() const;
  void _internal_set_replace(bool value);
  public:

  // .pg_query.ViewCheckOption with_check_option = 6 [json_name = "withCheckOption"];
  void clear_with_check_option();
  ::pg_query::ViewCheckOption with_check_option() const;
  void set_with_check_option(::pg_query::ViewCheckOption value);
  private:
  ::pg_query::ViewCheckOption _internal_with_check_option() const;
  void _internal_set_with_check_option(::pg_query::ViewCheckOption value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ViewStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > aliases_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::pg_query::RangeVar* view_;
  ::pg_query::Node* query_;
  bool replace_;
  int with_check_option_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class LoadStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.LoadStmt) */ {
 public:
  inline LoadStmt() : LoadStmt(nullptr) {}
  virtual ~LoadStmt();

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

  inline LoadStmt& operator=(const LoadStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline LoadStmt& operator=(LoadStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LoadStmt& default_instance();

  static inline const LoadStmt* internal_default_instance() {
    return reinterpret_cast<const LoadStmt*>(
               &_LoadStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    96;

  friend void swap(LoadStmt& a, LoadStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(LoadStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LoadStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline LoadStmt* New() const final {
    return CreateMaybeMessage<LoadStmt>(nullptr);
  }

  LoadStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LoadStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LoadStmt& from);
  void MergeFrom(const LoadStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LoadStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.LoadStmt";
  }
  protected:
  explicit LoadStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kFilenameFieldNumber = 1,
  };
  // string filename = 1 [json_name = "filename"];
  void clear_filename();
  const std::string& filename() const;
  void set_filename(const std::string& value);
  void set_filename(std::string&& value);
  void set_filename(const char* value);
  void set_filename(const char* value, size_t size);
  std::string* mutable_filename();
  std::string* release_filename();
  void set_allocated_filename(std::string* filename);
  private:
  const std::string& _internal_filename() const;
  void _internal_set_filename(const std::string& value);
  std::string* _internal_mutable_filename();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.LoadStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateDomainStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateDomainStmt) */ {
 public:
  inline CreateDomainStmt() : CreateDomainStmt(nullptr) {}
  virtual ~CreateDomainStmt();

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

  inline CreateDomainStmt& operator=(const CreateDomainStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateDomainStmt& operator=(CreateDomainStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateDomainStmt& default_instance();

  static inline const CreateDomainStmt* internal_default_instance() {
    return reinterpret_cast<const CreateDomainStmt*>(
               &_CreateDomainStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    97;

  friend void swap(CreateDomainStmt& a, CreateDomainStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateDomainStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateDomainStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateDomainStmt* New() const final {
    return CreateMaybeMessage<CreateDomainStmt>(nullptr);
  }

  CreateDomainStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateDomainStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateDomainStmt& from);
  void MergeFrom(const CreateDomainStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateDomainStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateDomainStmt";
  }
  protected:
  explicit CreateDomainStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDomainnameFieldNumber = 1,
    kConstraintsFieldNumber = 4,
    kTypeNameFieldNumber = 2,
    kCollClauseFieldNumber = 3,
  };
  // repeated .pg_query.Node domainname = 1 [json_name = "domainname"];
  int domainname_size() const;
  private:
  int _internal_domainname_size() const;
  public:
  void clear_domainname();
  ::pg_query::Node* mutable_domainname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_domainname();
  private:
  const ::pg_query::Node& _internal_domainname(int index) const;
  ::pg_query::Node* _internal_add_domainname();
  public:
  const ::pg_query::Node& domainname(int index) const;
  ::pg_query::Node* add_domainname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      domainname() const;

  // repeated .pg_query.Node constraints = 4 [json_name = "constraints"];
  int constraints_size() const;
  private:
  int _internal_constraints_size() const;
  public:
  void clear_constraints();
  ::pg_query::Node* mutable_constraints(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_constraints();
  private:
  const ::pg_query::Node& _internal_constraints(int index) const;
  ::pg_query::Node* _internal_add_constraints();
  public:
  const ::pg_query::Node& constraints(int index) const;
  ::pg_query::Node* add_constraints();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      constraints() const;

  // .pg_query.TypeName type_name = 2 [json_name = "typeName"];
  bool has_type_name() const;
  private:
  bool _internal_has_type_name() const;
  public:
  void clear_type_name();
  const ::pg_query::TypeName& type_name() const;
  ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* type_name);
  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();
  public:
  void unsafe_arena_set_allocated_type_name(
      ::pg_query::TypeName* type_name);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  // .pg_query.CollateClause coll_clause = 3 [json_name = "collClause"];
  bool has_coll_clause() const;
  private:
  bool _internal_has_coll_clause() const;
  public:
  void clear_coll_clause();
  const ::pg_query::CollateClause& coll_clause() const;
  ::pg_query::CollateClause* release_coll_clause();
  ::pg_query::CollateClause* mutable_coll_clause();
  void set_allocated_coll_clause(::pg_query::CollateClause* coll_clause);
  private:
  const ::pg_query::CollateClause& _internal_coll_clause() const;
  ::pg_query::CollateClause* _internal_mutable_coll_clause();
  public:
  void unsafe_arena_set_allocated_coll_clause(
      ::pg_query::CollateClause* coll_clause);
  ::pg_query::CollateClause* unsafe_arena_release_coll_clause();

  // @@protoc_insertion_point(class_scope:pg_query.CreateDomainStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > domainname_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > constraints_;
  ::pg_query::TypeName* type_name_;
  ::pg_query::CollateClause* coll_clause_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreatedbStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreatedbStmt) */ {
 public:
  inline CreatedbStmt() : CreatedbStmt(nullptr) {}
  virtual ~CreatedbStmt();

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

  inline CreatedbStmt& operator=(const CreatedbStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreatedbStmt& operator=(CreatedbStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreatedbStmt& default_instance();

  static inline const CreatedbStmt* internal_default_instance() {
    return reinterpret_cast<const CreatedbStmt*>(
               &_CreatedbStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    98;

  friend void swap(CreatedbStmt& a, CreatedbStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreatedbStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreatedbStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreatedbStmt* New() const final {
    return CreateMaybeMessage<CreatedbStmt>(nullptr);
  }

  CreatedbStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreatedbStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreatedbStmt& from);
  void MergeFrom(const CreatedbStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreatedbStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreatedbStmt";
  }
  protected:
  explicit CreatedbStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 2,
    kDbnameFieldNumber = 1,
  };
  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string dbname = 1 [json_name = "dbname"];
  void clear_dbname();
  const std::string& dbname() const;
  void set_dbname(const std::string& value);
  void set_dbname(std::string&& value);
  void set_dbname(const char* value);
  void set_dbname(const char* value, size_t size);
  std::string* mutable_dbname();
  std::string* release_dbname();
  void set_allocated_dbname(std::string* dbname);
  private:
  const std::string& _internal_dbname() const;
  void _internal_set_dbname(const std::string& value);
  std::string* _internal_mutable_dbname();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreatedbStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dbname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class DropdbStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropdbStmt) */ {
 public:
  inline DropdbStmt() : DropdbStmt(nullptr) {}
  virtual ~DropdbStmt();

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

  inline DropdbStmt& operator=(const DropdbStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline DropdbStmt& operator=(DropdbStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DropdbStmt& default_instance();

  static inline const DropdbStmt* internal_default_instance() {
    return reinterpret_cast<const DropdbStmt*>(
               &_DropdbStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    99;

  friend void swap(DropdbStmt& a, DropdbStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(DropdbStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DropdbStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline DropdbStmt* New() const final {
    return CreateMaybeMessage<DropdbStmt>(nullptr);
  }

  DropdbStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DropdbStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DropdbStmt& from);
  void MergeFrom(const DropdbStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DropdbStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DropdbStmt";
  }
  protected:
  explicit DropdbStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 3,
    kDbnameFieldNumber = 1,
    kMissingOkFieldNumber = 2,
  };
  // repeated .pg_query.Node options = 3 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string dbname = 1 [json_name = "dbname"];
  void clear_dbname();
  const std::string& dbname() const;
  void set_dbname(const std::string& value);
  void set_dbname(std::string&& value);
  void set_dbname(const char* value);
  void set_dbname(const char* value, size_t size);
  std::string* mutable_dbname();
  std::string* release_dbname();
  void set_allocated_dbname(std::string* dbname);
  private:
  const std::string& _internal_dbname() const;
  void _internal_set_dbname(const std::string& value);
  std::string* _internal_mutable_dbname();
  public:

  // bool missing_ok = 2 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.DropdbStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dbname_;
  bool missing_ok_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class VacuumStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.VacuumStmt) */ {
 public:
  inline VacuumStmt() : VacuumStmt(nullptr) {}
  virtual ~VacuumStmt();

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

  inline VacuumStmt& operator=(const VacuumStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline VacuumStmt& operator=(VacuumStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const VacuumStmt& default_instance();

  static inline const VacuumStmt* internal_default_instance() {
    return reinterpret_cast<const VacuumStmt*>(
               &_VacuumStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    100;

  friend void swap(VacuumStmt& a, VacuumStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(VacuumStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VacuumStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline VacuumStmt* New() const final {
    return CreateMaybeMessage<VacuumStmt>(nullptr);
  }

  VacuumStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VacuumStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const VacuumStmt& from);
  void MergeFrom(const VacuumStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(VacuumStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.VacuumStmt";
  }
  protected:
  explicit VacuumStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 1,
    kRelsFieldNumber = 2,
    kIsVacuumcmdFieldNumber = 3,
  };
  // repeated .pg_query.Node options = 1 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // repeated .pg_query.Node rels = 2 [json_name = "rels"];
  int rels_size() const;
  private:
  int _internal_rels_size() const;
  public:
  void clear_rels();
  ::pg_query::Node* mutable_rels(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_rels();
  private:
  const ::pg_query::Node& _internal_rels(int index) const;
  ::pg_query::Node* _internal_add_rels();
  public:
  const ::pg_query::Node& rels(int index) const;
  ::pg_query::Node* add_rels();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      rels() const;

  // bool is_vacuumcmd = 3 [json_name = "is_vacuumcmd"];
  void clear_is_vacuumcmd();
  bool is_vacuumcmd() const;
  void set_is_vacuumcmd(bool value);
  private:
  bool _internal_is_vacuumcmd() const;
  void _internal_set_is_vacuumcmd(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.VacuumStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > rels_;
  bool is_vacuumcmd_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ExplainStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ExplainStmt) */ {
 public:
  inline ExplainStmt() : ExplainStmt(nullptr) {}
  virtual ~ExplainStmt();

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

  inline ExplainStmt& operator=(const ExplainStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExplainStmt& operator=(ExplainStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ExplainStmt& default_instance();

  static inline const ExplainStmt* internal_default_instance() {
    return reinterpret_cast<const ExplainStmt*>(
               &_ExplainStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    101;

  friend void swap(ExplainStmt& a, ExplainStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ExplainStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ExplainStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ExplainStmt* New() const final {
    return CreateMaybeMessage<ExplainStmt>(nullptr);
  }

  ExplainStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ExplainStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ExplainStmt& from);
  void MergeFrom(const ExplainStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ExplainStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ExplainStmt";
  }
  protected:
  explicit ExplainStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 2,
    kQueryFieldNumber = 1,
  };
  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // .pg_query.Node query = 1 [json_name = "query"];
  bool has_query() const;
  private:
  bool _internal_has_query() const;
  public:
  void clear_query();
  const ::pg_query::Node& query() const;
  ::pg_query::Node* release_query();
  ::pg_query::Node* mutable_query();
  void set_allocated_query(::pg_query::Node* query);
  private:
  const ::pg_query::Node& _internal_query() const;
  ::pg_query::Node* _internal_mutable_query();
  public:
  void unsafe_arena_set_allocated_query(
      ::pg_query::Node* query);
  ::pg_query::Node* unsafe_arena_release_query();

  // @@protoc_insertion_point(class_scope:pg_query.ExplainStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::pg_query::Node* query_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateTableAsStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateTableAsStmt) */ {
 public:
  inline CreateTableAsStmt() : CreateTableAsStmt(nullptr) {}
  virtual ~CreateTableAsStmt();

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

  inline CreateTableAsStmt& operator=(const CreateTableAsStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateTableAsStmt& operator=(CreateTableAsStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateTableAsStmt& default_instance();

  static inline const CreateTableAsStmt* internal_default_instance() {
    return reinterpret_cast<const CreateTableAsStmt*>(
               &_CreateTableAsStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    102;

  friend void swap(CreateTableAsStmt& a, CreateTableAsStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateTableAsStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateTableAsStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateTableAsStmt* New() const final {
    return CreateMaybeMessage<CreateTableAsStmt>(nullptr);
  }

  CreateTableAsStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateTableAsStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateTableAsStmt& from);
  void MergeFrom(const CreateTableAsStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateTableAsStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateTableAsStmt";
  }
  protected:
  explicit CreateTableAsStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kQueryFieldNumber = 1,
    kIntoFieldNumber = 2,
    kRelkindFieldNumber = 3,
    kIsSelectIntoFieldNumber = 4,
    kIfNotExistsFieldNumber = 5,
  };
  // .pg_query.Node query = 1 [json_name = "query"];
  bool has_query() const;
  private:
  bool _internal_has_query() const;
  public:
  void clear_query();
  const ::pg_query::Node& query() const;
  ::pg_query::Node* release_query();
  ::pg_query::Node* mutable_query();
  void set_allocated_query(::pg_query::Node* query);
  private:
  const ::pg_query::Node& _internal_query() const;
  ::pg_query::Node* _internal_mutable_query();
  public:
  void unsafe_arena_set_allocated_query(
      ::pg_query::Node* query);
  ::pg_query::Node* unsafe_arena_release_query();

  // .pg_query.IntoClause into = 2 [json_name = "into"];
  bool has_into() const;
  private:
  bool _internal_has_into() const;
  public:
  void clear_into();
  const ::pg_query::IntoClause& into() const;
  ::pg_query::IntoClause* release_into();
  ::pg_query::IntoClause* mutable_into();
  void set_allocated_into(::pg_query::IntoClause* into);
  private:
  const ::pg_query::IntoClause& _internal_into() const;
  ::pg_query::IntoClause* _internal_mutable_into();
  public:
  void unsafe_arena_set_allocated_into(
      ::pg_query::IntoClause* into);
  ::pg_query::IntoClause* unsafe_arena_release_into();

  // .pg_query.ObjectType relkind = 3 [json_name = "relkind"];
  void clear_relkind();
  ::pg_query::ObjectType relkind() const;
  void set_relkind(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_relkind() const;
  void _internal_set_relkind(::pg_query::ObjectType value);
  public:

  // bool is_select_into = 4 [json_name = "is_select_into"];
  void clear_is_select_into();
  bool is_select_into() const;
  void set_is_select_into(bool value);
  private:
  bool _internal_is_select_into() const;
  void _internal_set_is_select_into(bool value);
  public:

  // bool if_not_exists = 5 [json_name = "if_not_exists"];
  void clear_if_not_exists();
  bool if_not_exists() const;
  void set_if_not_exists(bool value);
  private:
  bool _internal_if_not_exists() const;
  void _internal_set_if_not_exists(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateTableAsStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* query_;
  ::pg_query::IntoClause* into_;
  int relkind_;
  bool is_select_into_;
  bool if_not_exists_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateSeqStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateSeqStmt) */ {
 public:
  inline CreateSeqStmt() : CreateSeqStmt(nullptr) {}
  virtual ~CreateSeqStmt();

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

  inline CreateSeqStmt& operator=(const CreateSeqStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateSeqStmt& operator=(CreateSeqStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateSeqStmt& default_instance();

  static inline const CreateSeqStmt* internal_default_instance() {
    return reinterpret_cast<const CreateSeqStmt*>(
               &_CreateSeqStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    103;

  friend void swap(CreateSeqStmt& a, CreateSeqStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateSeqStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateSeqStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateSeqStmt* New() const final {
    return CreateMaybeMessage<CreateSeqStmt>(nullptr);
  }

  CreateSeqStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateSeqStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateSeqStmt& from);
  void MergeFrom(const CreateSeqStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateSeqStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateSeqStmt";
  }
  protected:
  explicit CreateSeqStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 2,
    kSequenceFieldNumber = 1,
    kOwnerIdFieldNumber = 3,
    kForIdentityFieldNumber = 4,
    kIfNotExistsFieldNumber = 5,
  };
  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // .pg_query.RangeVar sequence = 1 [json_name = "sequence"];
  bool has_sequence() const;
  private:
  bool _internal_has_sequence() const;
  public:
  void clear_sequence();
  const ::pg_query::RangeVar& sequence() const;
  ::pg_query::RangeVar* release_sequence();
  ::pg_query::RangeVar* mutable_sequence();
  void set_allocated_sequence(::pg_query::RangeVar* sequence);
  private:
  const ::pg_query::RangeVar& _internal_sequence() const;
  ::pg_query::RangeVar* _internal_mutable_sequence();
  public:
  void unsafe_arena_set_allocated_sequence(
      ::pg_query::RangeVar* sequence);
  ::pg_query::RangeVar* unsafe_arena_release_sequence();

  // uint32 owner_id = 3 [json_name = "ownerId"];
  void clear_owner_id();
  ::PROTOBUF_NAMESPACE_ID::uint32 owner_id() const;
  void set_owner_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_owner_id() const;
  void _internal_set_owner_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool for_identity = 4 [json_name = "for_identity"];
  void clear_for_identity();
  bool for_identity() const;
  void set_for_identity(bool value);
  private:
  bool _internal_for_identity() const;
  void _internal_set_for_identity(bool value);
  public:

  // bool if_not_exists = 5 [json_name = "if_not_exists"];
  void clear_if_not_exists();
  bool if_not_exists() const;
  void set_if_not_exists(bool value);
  private:
  bool _internal_if_not_exists() const;
  void _internal_set_if_not_exists(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateSeqStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::pg_query::RangeVar* sequence_;
  ::PROTOBUF_NAMESPACE_ID::uint32 owner_id_;
  bool for_identity_;
  bool if_not_exists_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterSeqStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterSeqStmt) */ {
 public:
  inline AlterSeqStmt() : AlterSeqStmt(nullptr) {}
  virtual ~AlterSeqStmt();

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

  inline AlterSeqStmt& operator=(const AlterSeqStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterSeqStmt& operator=(AlterSeqStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterSeqStmt& default_instance();

  static inline const AlterSeqStmt* internal_default_instance() {
    return reinterpret_cast<const AlterSeqStmt*>(
               &_AlterSeqStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    104;

  friend void swap(AlterSeqStmt& a, AlterSeqStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterSeqStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterSeqStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterSeqStmt* New() const final {
    return CreateMaybeMessage<AlterSeqStmt>(nullptr);
  }

  AlterSeqStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterSeqStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterSeqStmt& from);
  void MergeFrom(const AlterSeqStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterSeqStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterSeqStmt";
  }
  protected:
  explicit AlterSeqStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 2,
    kSequenceFieldNumber = 1,
    kForIdentityFieldNumber = 3,
    kMissingOkFieldNumber = 4,
  };
  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // .pg_query.RangeVar sequence = 1 [json_name = "sequence"];
  bool has_sequence() const;
  private:
  bool _internal_has_sequence() const;
  public:
  void clear_sequence();
  const ::pg_query::RangeVar& sequence() const;
  ::pg_query::RangeVar* release_sequence();
  ::pg_query::RangeVar* mutable_sequence();
  void set_allocated_sequence(::pg_query::RangeVar* sequence);
  private:
  const ::pg_query::RangeVar& _internal_sequence() const;
  ::pg_query::RangeVar* _internal_mutable_sequence();
  public:
  void unsafe_arena_set_allocated_sequence(
      ::pg_query::RangeVar* sequence);
  ::pg_query::RangeVar* unsafe_arena_release_sequence();

  // bool for_identity = 3 [json_name = "for_identity"];
  void clear_for_identity();
  bool for_identity() const;
  void set_for_identity(bool value);
  private:
  bool _internal_for_identity() const;
  void _internal_set_for_identity(bool value);
  public:

  // bool missing_ok = 4 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterSeqStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::pg_query::RangeVar* sequence_;
  bool for_identity_;
  bool missing_ok_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class VariableSetStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.VariableSetStmt) */ {
 public:
  inline VariableSetStmt() : VariableSetStmt(nullptr) {}
  virtual ~VariableSetStmt();

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

  inline VariableSetStmt& operator=(const VariableSetStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline VariableSetStmt& operator=(VariableSetStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const VariableSetStmt& default_instance();

  static inline const VariableSetStmt* internal_default_instance() {
    return reinterpret_cast<const VariableSetStmt*>(
               &_VariableSetStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    105;

  friend void swap(VariableSetStmt& a, VariableSetStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(VariableSetStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VariableSetStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline VariableSetStmt* New() const final {
    return CreateMaybeMessage<VariableSetStmt>(nullptr);
  }

  VariableSetStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VariableSetStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const VariableSetStmt& from);
  void MergeFrom(const VariableSetStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(VariableSetStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.VariableSetStmt";
  }
  protected:
  explicit VariableSetStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgsFieldNumber = 3,
    kNameFieldNumber = 2,
    kKindFieldNumber = 1,
    kIsLocalFieldNumber = 4,
  };
  // repeated .pg_query.Node args = 3 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // string name = 2 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .pg_query.VariableSetKind kind = 1 [json_name = "kind"];
  void clear_kind();
  ::pg_query::VariableSetKind kind() const;
  void set_kind(::pg_query::VariableSetKind value);
  private:
  ::pg_query::VariableSetKind _internal_kind() const;
  void _internal_set_kind(::pg_query::VariableSetKind value);
  public:

  // bool is_local = 4 [json_name = "is_local"];
  void clear_is_local();
  bool is_local() const;
  void set_is_local(bool value);
  private:
  bool _internal_is_local() const;
  void _internal_set_is_local(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.VariableSetStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  int kind_;
  bool is_local_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class VariableShowStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.VariableShowStmt) */ {
 public:
  inline VariableShowStmt() : VariableShowStmt(nullptr) {}
  virtual ~VariableShowStmt();

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

  inline VariableShowStmt& operator=(const VariableShowStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline VariableShowStmt& operator=(VariableShowStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const VariableShowStmt& default_instance();

  static inline const VariableShowStmt* internal_default_instance() {
    return reinterpret_cast<const VariableShowStmt*>(
               &_VariableShowStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    106;

  friend void swap(VariableShowStmt& a, VariableShowStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(VariableShowStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VariableShowStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline VariableShowStmt* New() const final {
    return CreateMaybeMessage<VariableShowStmt>(nullptr);
  }

  VariableShowStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VariableShowStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const VariableShowStmt& from);
  void MergeFrom(const VariableShowStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(VariableShowStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.VariableShowStmt";
  }
  protected:
  explicit VariableShowStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNameFieldNumber = 1,
  };
  // string name = 1 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.VariableShowStmt)
 private:
  class _Internal;

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

class DiscardStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DiscardStmt) */ {
 public:
  inline DiscardStmt() : DiscardStmt(nullptr) {}
  virtual ~DiscardStmt();

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

  inline DiscardStmt& operator=(const DiscardStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline DiscardStmt& operator=(DiscardStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DiscardStmt& default_instance();

  static inline const DiscardStmt* internal_default_instance() {
    return reinterpret_cast<const DiscardStmt*>(
               &_DiscardStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    107;

  friend void swap(DiscardStmt& a, DiscardStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(DiscardStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DiscardStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline DiscardStmt* New() const final {
    return CreateMaybeMessage<DiscardStmt>(nullptr);
  }

  DiscardStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DiscardStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DiscardStmt& from);
  void MergeFrom(const DiscardStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DiscardStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DiscardStmt";
  }
  protected:
  explicit DiscardStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTargetFieldNumber = 1,
  };
  // .pg_query.DiscardMode target = 1 [json_name = "target"];
  void clear_target();
  ::pg_query::DiscardMode target() const;
  void set_target(::pg_query::DiscardMode value);
  private:
  ::pg_query::DiscardMode _internal_target() const;
  void _internal_set_target(::pg_query::DiscardMode value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.DiscardStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int target_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateTrigStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateTrigStmt) */ {
 public:
  inline CreateTrigStmt() : CreateTrigStmt(nullptr) {}
  virtual ~CreateTrigStmt();

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

  inline CreateTrigStmt& operator=(const CreateTrigStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateTrigStmt& operator=(CreateTrigStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateTrigStmt& default_instance();

  static inline const CreateTrigStmt* internal_default_instance() {
    return reinterpret_cast<const CreateTrigStmt*>(
               &_CreateTrigStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    108;

  friend void swap(CreateTrigStmt& a, CreateTrigStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateTrigStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateTrigStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateTrigStmt* New() const final {
    return CreateMaybeMessage<CreateTrigStmt>(nullptr);
  }

  CreateTrigStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateTrigStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateTrigStmt& from);
  void MergeFrom(const CreateTrigStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateTrigStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateTrigStmt";
  }
  protected:
  explicit CreateTrigStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kFuncnameFieldNumber = 3,
    kArgsFieldNumber = 4,
    kColumnsFieldNumber = 8,
    kTransitionRelsFieldNumber = 11,
    kTrignameFieldNumber = 1,
    kRelationFieldNumber = 2,
    kWhenClauseFieldNumber = 9,
    kConstrrelFieldNumber = 14,
    kTimingFieldNumber = 6,
    kEventsFieldNumber = 7,
    kRowFieldNumber = 5,
    kIsconstraintFieldNumber = 10,
    kDeferrableFieldNumber = 12,
    kInitdeferredFieldNumber = 13,
  };
  // repeated .pg_query.Node funcname = 3 [json_name = "funcname"];
  int funcname_size() const;
  private:
  int _internal_funcname_size() const;
  public:
  void clear_funcname();
  ::pg_query::Node* mutable_funcname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_funcname();
  private:
  const ::pg_query::Node& _internal_funcname(int index) const;
  ::pg_query::Node* _internal_add_funcname();
  public:
  const ::pg_query::Node& funcname(int index) const;
  ::pg_query::Node* add_funcname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      funcname() const;

  // repeated .pg_query.Node args = 4 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // repeated .pg_query.Node columns = 8 [json_name = "columns"];
  int columns_size() const;
  private:
  int _internal_columns_size() const;
  public:
  void clear_columns();
  ::pg_query::Node* mutable_columns(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_columns();
  private:
  const ::pg_query::Node& _internal_columns(int index) const;
  ::pg_query::Node* _internal_add_columns();
  public:
  const ::pg_query::Node& columns(int index) const;
  ::pg_query::Node* add_columns();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      columns() const;

  // repeated .pg_query.Node transition_rels = 11 [json_name = "transitionRels"];
  int transition_rels_size() const;
  private:
  int _internal_transition_rels_size() const;
  public:
  void clear_transition_rels();
  ::pg_query::Node* mutable_transition_rels(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_transition_rels();
  private:
  const ::pg_query::Node& _internal_transition_rels(int index) const;
  ::pg_query::Node* _internal_add_transition_rels();
  public:
  const ::pg_query::Node& transition_rels(int index) const;
  ::pg_query::Node* add_transition_rels();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      transition_rels() const;

  // string trigname = 1 [json_name = "trigname"];
  void clear_trigname();
  const std::string& trigname() const;
  void set_trigname(const std::string& value);
  void set_trigname(std::string&& value);
  void set_trigname(const char* value);
  void set_trigname(const char* value, size_t size);
  std::string* mutable_trigname();
  std::string* release_trigname();
  void set_allocated_trigname(std::string* trigname);
  private:
  const std::string& _internal_trigname() const;
  void _internal_set_trigname(const std::string& value);
  std::string* _internal_mutable_trigname();
  public:

  // .pg_query.RangeVar relation = 2 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.Node when_clause = 9 [json_name = "whenClause"];
  bool has_when_clause() const;
  private:
  bool _internal_has_when_clause() const;
  public:
  void clear_when_clause();
  const ::pg_query::Node& when_clause() const;
  ::pg_query::Node* release_when_clause();
  ::pg_query::Node* mutable_when_clause();
  void set_allocated_when_clause(::pg_query::Node* when_clause);
  private:
  const ::pg_query::Node& _internal_when_clause() const;
  ::pg_query::Node* _internal_mutable_when_clause();
  public:
  void unsafe_arena_set_allocated_when_clause(
      ::pg_query::Node* when_clause);
  ::pg_query::Node* unsafe_arena_release_when_clause();

  // .pg_query.RangeVar constrrel = 14 [json_name = "constrrel"];
  bool has_constrrel() const;
  private:
  bool _internal_has_constrrel() const;
  public:
  void clear_constrrel();
  const ::pg_query::RangeVar& constrrel() const;
  ::pg_query::RangeVar* release_constrrel();
  ::pg_query::RangeVar* mutable_constrrel();
  void set_allocated_constrrel(::pg_query::RangeVar* constrrel);
  private:
  const ::pg_query::RangeVar& _internal_constrrel() const;
  ::pg_query::RangeVar* _internal_mutable_constrrel();
  public:
  void unsafe_arena_set_allocated_constrrel(
      ::pg_query::RangeVar* constrrel);
  ::pg_query::RangeVar* unsafe_arena_release_constrrel();

  // int32 timing = 6 [json_name = "timing"];
  void clear_timing();
  ::PROTOBUF_NAMESPACE_ID::int32 timing() const;
  void set_timing(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_timing() const;
  void _internal_set_timing(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 events = 7 [json_name = "events"];
  void clear_events();
  ::PROTOBUF_NAMESPACE_ID::int32 events() const;
  void set_events(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_events() const;
  void _internal_set_events(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool row = 5 [json_name = "row"];
  void clear_row();
  bool row() const;
  void set_row(bool value);
  private:
  bool _internal_row() const;
  void _internal_set_row(bool value);
  public:

  // bool isconstraint = 10 [json_name = "isconstraint"];
  void clear_isconstraint();
  bool isconstraint() const;
  void set_isconstraint(bool value);
  private:
  bool _internal_isconstraint() const;
  void _internal_set_isconstraint(bool value);
  public:

  // bool deferrable = 12 [json_name = "deferrable"];
  void clear_deferrable();
  bool deferrable() const;
  void set_deferrable(bool value);
  private:
  bool _internal_deferrable() const;
  void _internal_set_deferrable(bool value);
  public:

  // bool initdeferred = 13 [json_name = "initdeferred"];
  void clear_initdeferred();
  bool initdeferred() const;
  void set_initdeferred(bool value);
  private:
  bool _internal_initdeferred() const;
  void _internal_set_initdeferred(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateTrigStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funcname_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > columns_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > transition_rels_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr trigname_;
  ::pg_query::RangeVar* relation_;
  ::pg_query::Node* when_clause_;
  ::pg_query::RangeVar* constrrel_;
  ::PROTOBUF_NAMESPACE_ID::int32 timing_;
  ::PROTOBUF_NAMESPACE_ID::int32 events_;
  bool row_;
  bool isconstraint_;
  bool deferrable_;
  bool initdeferred_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreatePLangStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreatePLangStmt) */ {
 public:
  inline CreatePLangStmt() : CreatePLangStmt(nullptr) {}
  virtual ~CreatePLangStmt();

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

  inline CreatePLangStmt& operator=(const CreatePLangStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreatePLangStmt& operator=(CreatePLangStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreatePLangStmt& default_instance();

  static inline const CreatePLangStmt* internal_default_instance() {
    return reinterpret_cast<const CreatePLangStmt*>(
               &_CreatePLangStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    109;

  friend void swap(CreatePLangStmt& a, CreatePLangStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreatePLangStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreatePLangStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreatePLangStmt* New() const final {
    return CreateMaybeMessage<CreatePLangStmt>(nullptr);
  }

  CreatePLangStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreatePLangStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreatePLangStmt& from);
  void MergeFrom(const CreatePLangStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreatePLangStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreatePLangStmt";
  }
  protected:
  explicit CreatePLangStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPlhandlerFieldNumber = 3,
    kPlinlineFieldNumber = 4,
    kPlvalidatorFieldNumber = 5,
    kPlnameFieldNumber = 2,
    kReplaceFieldNumber = 1,
    kPltrustedFieldNumber = 6,
  };
  // repeated .pg_query.Node plhandler = 3 [json_name = "plhandler"];
  int plhandler_size() const;
  private:
  int _internal_plhandler_size() const;
  public:
  void clear_plhandler();
  ::pg_query::Node* mutable_plhandler(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_plhandler();
  private:
  const ::pg_query::Node& _internal_plhandler(int index) const;
  ::pg_query::Node* _internal_add_plhandler();
  public:
  const ::pg_query::Node& plhandler(int index) const;
  ::pg_query::Node* add_plhandler();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      plhandler() const;

  // repeated .pg_query.Node plinline = 4 [json_name = "plinline"];
  int plinline_size() const;
  private:
  int _internal_plinline_size() const;
  public:
  void clear_plinline();
  ::pg_query::Node* mutable_plinline(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_plinline();
  private:
  const ::pg_query::Node& _internal_plinline(int index) const;
  ::pg_query::Node* _internal_add_plinline();
  public:
  const ::pg_query::Node& plinline(int index) const;
  ::pg_query::Node* add_plinline();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      plinline() const;

  // repeated .pg_query.Node plvalidator = 5 [json_name = "plvalidator"];
  int plvalidator_size() const;
  private:
  int _internal_plvalidator_size() const;
  public:
  void clear_plvalidator();
  ::pg_query::Node* mutable_plvalidator(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_plvalidator();
  private:
  const ::pg_query::Node& _internal_plvalidator(int index) const;
  ::pg_query::Node* _internal_add_plvalidator();
  public:
  const ::pg_query::Node& plvalidator(int index) const;
  ::pg_query::Node* add_plvalidator();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      plvalidator() const;

  // string plname = 2 [json_name = "plname"];
  void clear_plname();
  const std::string& plname() const;
  void set_plname(const std::string& value);
  void set_plname(std::string&& value);
  void set_plname(const char* value);
  void set_plname(const char* value, size_t size);
  std::string* mutable_plname();
  std::string* release_plname();
  void set_allocated_plname(std::string* plname);
  private:
  const std::string& _internal_plname() const;
  void _internal_set_plname(const std::string& value);
  std::string* _internal_mutable_plname();
  public:

  // bool replace = 1 [json_name = "replace"];
  void clear_replace();
  bool replace() const;
  void set_replace(bool value);
  private:
  bool _internal_replace() const;
  void _internal_set_replace(bool value);
  public:

  // bool pltrusted = 6 [json_name = "pltrusted"];
  void clear_pltrusted();
  bool pltrusted() const;
  void set_pltrusted(bool value);
  private:
  bool _internal_pltrusted() const;
  void _internal_set_pltrusted(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreatePLangStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > plhandler_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > plinline_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > plvalidator_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr plname_;
  bool replace_;
  bool pltrusted_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateRoleStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateRoleStmt) */ {
 public:
  inline CreateRoleStmt() : CreateRoleStmt(nullptr) {}
  virtual ~CreateRoleStmt();

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

  inline CreateRoleStmt& operator=(const CreateRoleStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateRoleStmt& operator=(CreateRoleStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateRoleStmt& default_instance();

  static inline const CreateRoleStmt* internal_default_instance() {
    return reinterpret_cast<const CreateRoleStmt*>(
               &_CreateRoleStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    110;

  friend void swap(CreateRoleStmt& a, CreateRoleStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateRoleStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateRoleStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateRoleStmt* New() const final {
    return CreateMaybeMessage<CreateRoleStmt>(nullptr);
  }

  CreateRoleStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateRoleStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateRoleStmt& from);
  void MergeFrom(const CreateRoleStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateRoleStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateRoleStmt";
  }
  protected:
  explicit CreateRoleStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 3,
    kRoleFieldNumber = 2,
    kStmtTypeFieldNumber = 1,
  };
  // repeated .pg_query.Node options = 3 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string role = 2 [json_name = "role"];
  void clear_role();
  const std::string& role() const;
  void set_role(const std::string& value);
  void set_role(std::string&& value);
  void set_role(const char* value);
  void set_role(const char* value, size_t size);
  std::string* mutable_role();
  std::string* release_role();
  void set_allocated_role(std::string* role);
  private:
  const std::string& _internal_role() const;
  void _internal_set_role(const std::string& value);
  std::string* _internal_mutable_role();
  public:

  // .pg_query.RoleStmtType stmt_type = 1 [json_name = "stmt_type"];
  void clear_stmt_type();
  ::pg_query::RoleStmtType stmt_type() const;
  void set_stmt_type(::pg_query::RoleStmtType value);
  private:
  ::pg_query::RoleStmtType _internal_stmt_type() const;
  void _internal_set_stmt_type(::pg_query::RoleStmtType value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateRoleStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr role_;
  int stmt_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterRoleStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterRoleStmt) */ {
 public:
  inline AlterRoleStmt() : AlterRoleStmt(nullptr) {}
  virtual ~AlterRoleStmt();

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

  inline AlterRoleStmt& operator=(const AlterRoleStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterRoleStmt& operator=(AlterRoleStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterRoleStmt& default_instance();

  static inline const AlterRoleStmt* internal_default_instance() {
    return reinterpret_cast<const AlterRoleStmt*>(
               &_AlterRoleStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    111;

  friend void swap(AlterRoleStmt& a, AlterRoleStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterRoleStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterRoleStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterRoleStmt* New() const final {
    return CreateMaybeMessage<AlterRoleStmt>(nullptr);
  }

  AlterRoleStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterRoleStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterRoleStmt& from);
  void MergeFrom(const AlterRoleStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterRoleStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterRoleStmt";
  }
  protected:
  explicit AlterRoleStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 2,
    kRoleFieldNumber = 1,
    kActionFieldNumber = 3,
  };
  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // .pg_query.RoleSpec role = 1 [json_name = "role"];
  bool has_role() const;
  private:
  bool _internal_has_role() const;
  public:
  void clear_role();
  const ::pg_query::RoleSpec& role() const;
  ::pg_query::RoleSpec* release_role();
  ::pg_query::RoleSpec* mutable_role();
  void set_allocated_role(::pg_query::RoleSpec* role);
  private:
  const ::pg_query::RoleSpec& _internal_role() const;
  ::pg_query::RoleSpec* _internal_mutable_role();
  public:
  void unsafe_arena_set_allocated_role(
      ::pg_query::RoleSpec* role);
  ::pg_query::RoleSpec* unsafe_arena_release_role();

  // int32 action = 3 [json_name = "action"];
  void clear_action();
  ::PROTOBUF_NAMESPACE_ID::int32 action() const;
  void set_action(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_action() const;
  void _internal_set_action(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterRoleStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::pg_query::RoleSpec* role_;
  ::PROTOBUF_NAMESPACE_ID::int32 action_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class DropRoleStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropRoleStmt) */ {
 public:
  inline DropRoleStmt() : DropRoleStmt(nullptr) {}
  virtual ~DropRoleStmt();

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

  inline DropRoleStmt& operator=(const DropRoleStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline DropRoleStmt& operator=(DropRoleStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DropRoleStmt& default_instance();

  static inline const DropRoleStmt* internal_default_instance() {
    return reinterpret_cast<const DropRoleStmt*>(
               &_DropRoleStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    112;

  friend void swap(DropRoleStmt& a, DropRoleStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(DropRoleStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DropRoleStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline DropRoleStmt* New() const final {
    return CreateMaybeMessage<DropRoleStmt>(nullptr);
  }

  DropRoleStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DropRoleStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DropRoleStmt& from);
  void MergeFrom(const DropRoleStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DropRoleStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DropRoleStmt";
  }
  protected:
  explicit DropRoleStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRolesFieldNumber = 1,
    kMissingOkFieldNumber = 2,
  };
  // repeated .pg_query.Node roles = 1 [json_name = "roles"];
  int roles_size() const;
  private:
  int _internal_roles_size() const;
  public:
  void clear_roles();
  ::pg_query::Node* mutable_roles(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_roles();
  private:
  const ::pg_query::Node& _internal_roles(int index) const;
  ::pg_query::Node* _internal_add_roles();
  public:
  const ::pg_query::Node& roles(int index) const;
  ::pg_query::Node* add_roles();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      roles() const;

  // bool missing_ok = 2 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.DropRoleStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > roles_;
  bool missing_ok_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class LockStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.LockStmt) */ {
 public:
  inline LockStmt() : LockStmt(nullptr) {}
  virtual ~LockStmt();

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

  inline LockStmt& operator=(const LockStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline LockStmt& operator=(LockStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LockStmt& default_instance();

  static inline const LockStmt* internal_default_instance() {
    return reinterpret_cast<const LockStmt*>(
               &_LockStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    113;

  friend void swap(LockStmt& a, LockStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(LockStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LockStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline LockStmt* New() const final {
    return CreateMaybeMessage<LockStmt>(nullptr);
  }

  LockStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LockStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LockStmt& from);
  void MergeFrom(const LockStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LockStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.LockStmt";
  }
  protected:
  explicit LockStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRelationsFieldNumber = 1,
    kModeFieldNumber = 2,
    kNowaitFieldNumber = 3,
  };
  // repeated .pg_query.Node relations = 1 [json_name = "relations"];
  int relations_size() const;
  private:
  int _internal_relations_size() const;
  public:
  void clear_relations();
  ::pg_query::Node* mutable_relations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_relations();
  private:
  const ::pg_query::Node& _internal_relations(int index) const;
  ::pg_query::Node* _internal_add_relations();
  public:
  const ::pg_query::Node& relations(int index) const;
  ::pg_query::Node* add_relations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      relations() const;

  // int32 mode = 2 [json_name = "mode"];
  void clear_mode();
  ::PROTOBUF_NAMESPACE_ID::int32 mode() const;
  void set_mode(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_mode() const;
  void _internal_set_mode(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool nowait = 3 [json_name = "nowait"];
  void clear_nowait();
  bool nowait() const;
  void set_nowait(bool value);
  private:
  bool _internal_nowait() const;
  void _internal_set_nowait(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.LockStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > relations_;
  ::PROTOBUF_NAMESPACE_ID::int32 mode_;
  bool nowait_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ConstraintsSetStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ConstraintsSetStmt) */ {
 public:
  inline ConstraintsSetStmt() : ConstraintsSetStmt(nullptr) {}
  virtual ~ConstraintsSetStmt();

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

  inline ConstraintsSetStmt& operator=(const ConstraintsSetStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConstraintsSetStmt& operator=(ConstraintsSetStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ConstraintsSetStmt& default_instance();

  static inline const ConstraintsSetStmt* internal_default_instance() {
    return reinterpret_cast<const ConstraintsSetStmt*>(
               &_ConstraintsSetStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    114;

  friend void swap(ConstraintsSetStmt& a, ConstraintsSetStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ConstraintsSetStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ConstraintsSetStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ConstraintsSetStmt* New() const final {
    return CreateMaybeMessage<ConstraintsSetStmt>(nullptr);
  }

  ConstraintsSetStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ConstraintsSetStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ConstraintsSetStmt& from);
  void MergeFrom(const ConstraintsSetStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ConstraintsSetStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ConstraintsSetStmt";
  }
  protected:
  explicit ConstraintsSetStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kConstraintsFieldNumber = 1,
    kDeferredFieldNumber = 2,
  };
  // repeated .pg_query.Node constraints = 1 [json_name = "constraints"];
  int constraints_size() const;
  private:
  int _internal_constraints_size() const;
  public:
  void clear_constraints();
  ::pg_query::Node* mutable_constraints(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_constraints();
  private:
  const ::pg_query::Node& _internal_constraints(int index) const;
  ::pg_query::Node* _internal_add_constraints();
  public:
  const ::pg_query::Node& constraints(int index) const;
  ::pg_query::Node* add_constraints();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      constraints() const;

  // bool deferred = 2 [json_name = "deferred"];
  void clear_deferred();
  bool deferred() const;
  void set_deferred(bool value);
  private:
  bool _internal_deferred() const;
  void _internal_set_deferred(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ConstraintsSetStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > constraints_;
  bool deferred_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ReindexStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ReindexStmt) */ {
 public:
  inline ReindexStmt() : ReindexStmt(nullptr) {}
  virtual ~ReindexStmt();

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

  inline ReindexStmt& operator=(const ReindexStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReindexStmt& operator=(ReindexStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ReindexStmt& default_instance();

  static inline const ReindexStmt* internal_default_instance() {
    return reinterpret_cast<const ReindexStmt*>(
               &_ReindexStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    115;

  friend void swap(ReindexStmt& a, ReindexStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ReindexStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ReindexStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ReindexStmt* New() const final {
    return CreateMaybeMessage<ReindexStmt>(nullptr);
  }

  ReindexStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ReindexStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ReindexStmt& from);
  void MergeFrom(const ReindexStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReindexStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ReindexStmt";
  }
  protected:
  explicit ReindexStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNameFieldNumber = 3,
    kRelationFieldNumber = 2,
    kKindFieldNumber = 1,
    kOptionsFieldNumber = 4,
    kConcurrentFieldNumber = 5,
  };
  // string name = 3 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .pg_query.RangeVar relation = 2 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.ReindexObjectType kind = 1 [json_name = "kind"];
  void clear_kind();
  ::pg_query::ReindexObjectType kind() const;
  void set_kind(::pg_query::ReindexObjectType value);
  private:
  ::pg_query::ReindexObjectType _internal_kind() const;
  void _internal_set_kind(::pg_query::ReindexObjectType value);
  public:

  // int32 options = 4 [json_name = "options"];
  void clear_options();
  ::PROTOBUF_NAMESPACE_ID::int32 options() const;
  void set_options(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_options() const;
  void _internal_set_options(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool concurrent = 5 [json_name = "concurrent"];
  void clear_concurrent();
  bool concurrent() const;
  void set_concurrent(bool value);
  private:
  bool _internal_concurrent() const;
  void _internal_set_concurrent(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ReindexStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::pg_query::RangeVar* relation_;
  int kind_;
  ::PROTOBUF_NAMESPACE_ID::int32 options_;
  bool concurrent_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CheckPointStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CheckPointStmt) */ {
 public:
  inline CheckPointStmt() : CheckPointStmt(nullptr) {}
  virtual ~CheckPointStmt();

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

  inline CheckPointStmt& operator=(const CheckPointStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CheckPointStmt& operator=(CheckPointStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CheckPointStmt& default_instance();

  static inline const CheckPointStmt* internal_default_instance() {
    return reinterpret_cast<const CheckPointStmt*>(
               &_CheckPointStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    116;

  friend void swap(CheckPointStmt& a, CheckPointStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CheckPointStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CheckPointStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CheckPointStmt* New() const final {
    return CreateMaybeMessage<CheckPointStmt>(nullptr);
  }

  CheckPointStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CheckPointStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CheckPointStmt& from);
  void MergeFrom(const CheckPointStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CheckPointStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CheckPointStmt";
  }
  protected:
  explicit CheckPointStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // @@protoc_insertion_point(class_scope:pg_query.CheckPointStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateSchemaStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateSchemaStmt) */ {
 public:
  inline CreateSchemaStmt() : CreateSchemaStmt(nullptr) {}
  virtual ~CreateSchemaStmt();

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

  inline CreateSchemaStmt& operator=(const CreateSchemaStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateSchemaStmt& operator=(CreateSchemaStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateSchemaStmt& default_instance();

  static inline const CreateSchemaStmt* internal_default_instance() {
    return reinterpret_cast<const CreateSchemaStmt*>(
               &_CreateSchemaStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    117;

  friend void swap(CreateSchemaStmt& a, CreateSchemaStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateSchemaStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateSchemaStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateSchemaStmt* New() const final {
    return CreateMaybeMessage<CreateSchemaStmt>(nullptr);
  }

  CreateSchemaStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateSchemaStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateSchemaStmt& from);
  void MergeFrom(const CreateSchemaStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateSchemaStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateSchemaStmt";
  }
  protected:
  explicit CreateSchemaStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSchemaEltsFieldNumber = 3,
    kSchemanameFieldNumber = 1,
    kAuthroleFieldNumber = 2,
    kIfNotExistsFieldNumber = 4,
  };
  // repeated .pg_query.Node schema_elts = 3 [json_name = "schemaElts"];
  int schema_elts_size() const;
  private:
  int _internal_schema_elts_size() const;
  public:
  void clear_schema_elts();
  ::pg_query::Node* mutable_schema_elts(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_schema_elts();
  private:
  const ::pg_query::Node& _internal_schema_elts(int index) const;
  ::pg_query::Node* _internal_add_schema_elts();
  public:
  const ::pg_query::Node& schema_elts(int index) const;
  ::pg_query::Node* add_schema_elts();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      schema_elts() const;

  // string schemaname = 1 [json_name = "schemaname"];
  void clear_schemaname();
  const std::string& schemaname() const;
  void set_schemaname(const std::string& value);
  void set_schemaname(std::string&& value);
  void set_schemaname(const char* value);
  void set_schemaname(const char* value, size_t size);
  std::string* mutable_schemaname();
  std::string* release_schemaname();
  void set_allocated_schemaname(std::string* schemaname);
  private:
  const std::string& _internal_schemaname() const;
  void _internal_set_schemaname(const std::string& value);
  std::string* _internal_mutable_schemaname();
  public:

  // .pg_query.RoleSpec authrole = 2 [json_name = "authrole"];
  bool has_authrole() const;
  private:
  bool _internal_has_authrole() const;
  public:
  void clear_authrole();
  const ::pg_query::RoleSpec& authrole() const;
  ::pg_query::RoleSpec* release_authrole();
  ::pg_query::RoleSpec* mutable_authrole();
  void set_allocated_authrole(::pg_query::RoleSpec* authrole);
  private:
  const ::pg_query::RoleSpec& _internal_authrole() const;
  ::pg_query::RoleSpec* _internal_mutable_authrole();
  public:
  void unsafe_arena_set_allocated_authrole(
      ::pg_query::RoleSpec* authrole);
  ::pg_query::RoleSpec* unsafe_arena_release_authrole();

  // bool if_not_exists = 4 [json_name = "if_not_exists"];
  void clear_if_not_exists();
  bool if_not_exists() const;
  void set_if_not_exists(bool value);
  private:
  bool _internal_if_not_exists() const;
  void _internal_set_if_not_exists(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateSchemaStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > schema_elts_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr schemaname_;
  ::pg_query::RoleSpec* authrole_;
  bool if_not_exists_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterDatabaseStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDatabaseStmt) */ {
 public:
  inline AlterDatabaseStmt() : AlterDatabaseStmt(nullptr) {}
  virtual ~AlterDatabaseStmt();

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

  inline AlterDatabaseStmt& operator=(const AlterDatabaseStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterDatabaseStmt& operator=(AlterDatabaseStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterDatabaseStmt& default_instance();

  static inline const AlterDatabaseStmt* internal_default_instance() {
    return reinterpret_cast<const AlterDatabaseStmt*>(
               &_AlterDatabaseStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    118;

  friend void swap(AlterDatabaseStmt& a, AlterDatabaseStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterDatabaseStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterDatabaseStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterDatabaseStmt* New() const final {
    return CreateMaybeMessage<AlterDatabaseStmt>(nullptr);
  }

  AlterDatabaseStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterDatabaseStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterDatabaseStmt& from);
  void MergeFrom(const AlterDatabaseStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterDatabaseStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterDatabaseStmt";
  }
  protected:
  explicit AlterDatabaseStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 2,
    kDbnameFieldNumber = 1,
  };
  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string dbname = 1 [json_name = "dbname"];
  void clear_dbname();
  const std::string& dbname() const;
  void set_dbname(const std::string& value);
  void set_dbname(std::string&& value);
  void set_dbname(const char* value);
  void set_dbname(const char* value, size_t size);
  std::string* mutable_dbname();
  std::string* release_dbname();
  void set_allocated_dbname(std::string* dbname);
  private:
  const std::string& _internal_dbname() const;
  void _internal_set_dbname(const std::string& value);
  std::string* _internal_mutable_dbname();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterDatabaseStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dbname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterDatabaseSetStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDatabaseSetStmt) */ {
 public:
  inline AlterDatabaseSetStmt() : AlterDatabaseSetStmt(nullptr) {}
  virtual ~AlterDatabaseSetStmt();

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

  inline AlterDatabaseSetStmt& operator=(const AlterDatabaseSetStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterDatabaseSetStmt& operator=(AlterDatabaseSetStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterDatabaseSetStmt& default_instance();

  static inline const AlterDatabaseSetStmt* internal_default_instance() {
    return reinterpret_cast<const AlterDatabaseSetStmt*>(
               &_AlterDatabaseSetStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    119;

  friend void swap(AlterDatabaseSetStmt& a, AlterDatabaseSetStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterDatabaseSetStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterDatabaseSetStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterDatabaseSetStmt* New() const final {
    return CreateMaybeMessage<AlterDatabaseSetStmt>(nullptr);
  }

  AlterDatabaseSetStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterDatabaseSetStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterDatabaseSetStmt& from);
  void MergeFrom(const AlterDatabaseSetStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterDatabaseSetStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterDatabaseSetStmt";
  }
  protected:
  explicit AlterDatabaseSetStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDbnameFieldNumber = 1,
    kSetstmtFieldNumber = 2,
  };
  // string dbname = 1 [json_name = "dbname"];
  void clear_dbname();
  const std::string& dbname() const;
  void set_dbname(const std::string& value);
  void set_dbname(std::string&& value);
  void set_dbname(const char* value);
  void set_dbname(const char* value, size_t size);
  std::string* mutable_dbname();
  std::string* release_dbname();
  void set_allocated_dbname(std::string* dbname);
  private:
  const std::string& _internal_dbname() const;
  void _internal_set_dbname(const std::string& value);
  std::string* _internal_mutable_dbname();
  public:

  // .pg_query.VariableSetStmt setstmt = 2 [json_name = "setstmt"];
  bool has_setstmt() const;
  private:
  bool _internal_has_setstmt() const;
  public:
  void clear_setstmt();
  const ::pg_query::VariableSetStmt& setstmt() const;
  ::pg_query::VariableSetStmt* release_setstmt();
  ::pg_query::VariableSetStmt* mutable_setstmt();
  void set_allocated_setstmt(::pg_query::VariableSetStmt* setstmt);
  private:
  const ::pg_query::VariableSetStmt& _internal_setstmt() const;
  ::pg_query::VariableSetStmt* _internal_mutable_setstmt();
  public:
  void unsafe_arena_set_allocated_setstmt(
      ::pg_query::VariableSetStmt* setstmt);
  ::pg_query::VariableSetStmt* unsafe_arena_release_setstmt();

  // @@protoc_insertion_point(class_scope:pg_query.AlterDatabaseSetStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dbname_;
  ::pg_query::VariableSetStmt* setstmt_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterRoleSetStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterRoleSetStmt) */ {
 public:
  inline AlterRoleSetStmt() : AlterRoleSetStmt(nullptr) {}
  virtual ~AlterRoleSetStmt();

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

  inline AlterRoleSetStmt& operator=(const AlterRoleSetStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterRoleSetStmt& operator=(AlterRoleSetStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterRoleSetStmt& default_instance();

  static inline const AlterRoleSetStmt* internal_default_instance() {
    return reinterpret_cast<const AlterRoleSetStmt*>(
               &_AlterRoleSetStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    120;

  friend void swap(AlterRoleSetStmt& a, AlterRoleSetStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterRoleSetStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterRoleSetStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterRoleSetStmt* New() const final {
    return CreateMaybeMessage<AlterRoleSetStmt>(nullptr);
  }

  AlterRoleSetStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterRoleSetStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterRoleSetStmt& from);
  void MergeFrom(const AlterRoleSetStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterRoleSetStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterRoleSetStmt";
  }
  protected:
  explicit AlterRoleSetStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDatabaseFieldNumber = 2,
    kRoleFieldNumber = 1,
    kSetstmtFieldNumber = 3,
  };
  // string database = 2 [json_name = "database"];
  void clear_database();
  const std::string& database() const;
  void set_database(const std::string& value);
  void set_database(std::string&& value);
  void set_database(const char* value);
  void set_database(const char* value, size_t size);
  std::string* mutable_database();
  std::string* release_database();
  void set_allocated_database(std::string* database);
  private:
  const std::string& _internal_database() const;
  void _internal_set_database(const std::string& value);
  std::string* _internal_mutable_database();
  public:

  // .pg_query.RoleSpec role = 1 [json_name = "role"];
  bool has_role() const;
  private:
  bool _internal_has_role() const;
  public:
  void clear_role();
  const ::pg_query::RoleSpec& role() const;
  ::pg_query::RoleSpec* release_role();
  ::pg_query::RoleSpec* mutable_role();
  void set_allocated_role(::pg_query::RoleSpec* role);
  private:
  const ::pg_query::RoleSpec& _internal_role() const;
  ::pg_query::RoleSpec* _internal_mutable_role();
  public:
  void unsafe_arena_set_allocated_role(
      ::pg_query::RoleSpec* role);
  ::pg_query::RoleSpec* unsafe_arena_release_role();

  // .pg_query.VariableSetStmt setstmt = 3 [json_name = "setstmt"];
  bool has_setstmt() const;
  private:
  bool _internal_has_setstmt() const;
  public:
  void clear_setstmt();
  const ::pg_query::VariableSetStmt& setstmt() const;
  ::pg_query::VariableSetStmt* release_setstmt();
  ::pg_query::VariableSetStmt* mutable_setstmt();
  void set_allocated_setstmt(::pg_query::VariableSetStmt* setstmt);
  private:
  const ::pg_query::VariableSetStmt& _internal_setstmt() const;
  ::pg_query::VariableSetStmt* _internal_mutable_setstmt();
  public:
  void unsafe_arena_set_allocated_setstmt(
      ::pg_query::VariableSetStmt* setstmt);
  ::pg_query::VariableSetStmt* unsafe_arena_release_setstmt();

  // @@protoc_insertion_point(class_scope:pg_query.AlterRoleSetStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr database_;
  ::pg_query::RoleSpec* role_;
  ::pg_query::VariableSetStmt* setstmt_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateConversionStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateConversionStmt) */ {
 public:
  inline CreateConversionStmt() : CreateConversionStmt(nullptr) {}
  virtual ~CreateConversionStmt();

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

  inline CreateConversionStmt& operator=(const CreateConversionStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateConversionStmt& operator=(CreateConversionStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateConversionStmt& default_instance();

  static inline const CreateConversionStmt* internal_default_instance() {
    return reinterpret_cast<const CreateConversionStmt*>(
               &_CreateConversionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    121;

  friend void swap(CreateConversionStmt& a, CreateConversionStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateConversionStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateConversionStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateConversionStmt* New() const final {
    return CreateMaybeMessage<CreateConversionStmt>(nullptr);
  }

  CreateConversionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateConversionStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateConversionStmt& from);
  void MergeFrom(const CreateConversionStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateConversionStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateConversionStmt";
  }
  protected:
  explicit CreateConversionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kConversionNameFieldNumber = 1,
    kFuncNameFieldNumber = 4,
    kForEncodingNameFieldNumber = 2,
    kToEncodingNameFieldNumber = 3,
    kDefFieldNumber = 5,
  };
  // repeated .pg_query.Node conversion_name = 1 [json_name = "conversion_name"];
  int conversion_name_size() const;
  private:
  int _internal_conversion_name_size() const;
  public:
  void clear_conversion_name();
  ::pg_query::Node* mutable_conversion_name(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_conversion_name();
  private:
  const ::pg_query::Node& _internal_conversion_name(int index) const;
  ::pg_query::Node* _internal_add_conversion_name();
  public:
  const ::pg_query::Node& conversion_name(int index) const;
  ::pg_query::Node* add_conversion_name();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      conversion_name() const;

  // repeated .pg_query.Node func_name = 4 [json_name = "func_name"];
  int func_name_size() const;
  private:
  int _internal_func_name_size() const;
  public:
  void clear_func_name();
  ::pg_query::Node* mutable_func_name(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_func_name();
  private:
  const ::pg_query::Node& _internal_func_name(int index) const;
  ::pg_query::Node* _internal_add_func_name();
  public:
  const ::pg_query::Node& func_name(int index) const;
  ::pg_query::Node* add_func_name();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      func_name() const;

  // string for_encoding_name = 2 [json_name = "for_encoding_name"];
  void clear_for_encoding_name();
  const std::string& for_encoding_name() const;
  void set_for_encoding_name(const std::string& value);
  void set_for_encoding_name(std::string&& value);
  void set_for_encoding_name(const char* value);
  void set_for_encoding_name(const char* value, size_t size);
  std::string* mutable_for_encoding_name();
  std::string* release_for_encoding_name();
  void set_allocated_for_encoding_name(std::string* for_encoding_name);
  private:
  const std::string& _internal_for_encoding_name() const;
  void _internal_set_for_encoding_name(const std::string& value);
  std::string* _internal_mutable_for_encoding_name();
  public:

  // string to_encoding_name = 3 [json_name = "to_encoding_name"];
  void clear_to_encoding_name();
  const std::string& to_encoding_name() const;
  void set_to_encoding_name(const std::string& value);
  void set_to_encoding_name(std::string&& value);
  void set_to_encoding_name(const char* value);
  void set_to_encoding_name(const char* value, size_t size);
  std::string* mutable_to_encoding_name();
  std::string* release_to_encoding_name();
  void set_allocated_to_encoding_name(std::string* to_encoding_name);
  private:
  const std::string& _internal_to_encoding_name() const;
  void _internal_set_to_encoding_name(const std::string& value);
  std::string* _internal_mutable_to_encoding_name();
  public:

  // bool def = 5 [json_name = "def"];
  void clear_def();
  bool def() const;
  void set_def(bool value);
  private:
  bool _internal_def() const;
  void _internal_set_def(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateConversionStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > conversion_name_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > func_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr for_encoding_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr to_encoding_name_;
  bool def_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateCastStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateCastStmt) */ {
 public:
  inline CreateCastStmt() : CreateCastStmt(nullptr) {}
  virtual ~CreateCastStmt();

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

  inline CreateCastStmt& operator=(const CreateCastStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateCastStmt& operator=(CreateCastStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateCastStmt& default_instance();

  static inline const CreateCastStmt* internal_default_instance() {
    return reinterpret_cast<const CreateCastStmt*>(
               &_CreateCastStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    122;

  friend void swap(CreateCastStmt& a, CreateCastStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateCastStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateCastStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateCastStmt* New() const final {
    return CreateMaybeMessage<CreateCastStmt>(nullptr);
  }

  CreateCastStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateCastStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateCastStmt& from);
  void MergeFrom(const CreateCastStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateCastStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateCastStmt";
  }
  protected:
  explicit CreateCastStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSourcetypeFieldNumber = 1,
    kTargettypeFieldNumber = 2,
    kFuncFieldNumber = 3,
    kContextFieldNumber = 4,
    kInoutFieldNumber = 5,
  };
  // .pg_query.TypeName sourcetype = 1 [json_name = "sourcetype"];
  bool has_sourcetype() const;
  private:
  bool _internal_has_sourcetype() const;
  public:
  void clear_sourcetype();
  const ::pg_query::TypeName& sourcetype() const;
  ::pg_query::TypeName* release_sourcetype();
  ::pg_query::TypeName* mutable_sourcetype();
  void set_allocated_sourcetype(::pg_query::TypeName* sourcetype);
  private:
  const ::pg_query::TypeName& _internal_sourcetype() const;
  ::pg_query::TypeName* _internal_mutable_sourcetype();
  public:
  void unsafe_arena_set_allocated_sourcetype(
      ::pg_query::TypeName* sourcetype);
  ::pg_query::TypeName* unsafe_arena_release_sourcetype();

  // .pg_query.TypeName targettype = 2 [json_name = "targettype"];
  bool has_targettype() const;
  private:
  bool _internal_has_targettype() const;
  public:
  void clear_targettype();
  const ::pg_query::TypeName& targettype() const;
  ::pg_query::TypeName* release_targettype();
  ::pg_query::TypeName* mutable_targettype();
  void set_allocated_targettype(::pg_query::TypeName* targettype);
  private:
  const ::pg_query::TypeName& _internal_targettype() const;
  ::pg_query::TypeName* _internal_mutable_targettype();
  public:
  void unsafe_arena_set_allocated_targettype(
      ::pg_query::TypeName* targettype);
  ::pg_query::TypeName* unsafe_arena_release_targettype();

  // .pg_query.ObjectWithArgs func = 3 [json_name = "func"];
  bool has_func() const;
  private:
  bool _internal_has_func() const;
  public:
  void clear_func();
  const ::pg_query::ObjectWithArgs& func() const;
  ::pg_query::ObjectWithArgs* release_func();
  ::pg_query::ObjectWithArgs* mutable_func();
  void set_allocated_func(::pg_query::ObjectWithArgs* func);
  private:
  const ::pg_query::ObjectWithArgs& _internal_func() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_func();
  public:
  void unsafe_arena_set_allocated_func(
      ::pg_query::ObjectWithArgs* func);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_func();

  // .pg_query.CoercionContext context = 4 [json_name = "context"];
  void clear_context();
  ::pg_query::CoercionContext context() const;
  void set_context(::pg_query::CoercionContext value);
  private:
  ::pg_query::CoercionContext _internal_context() const;
  void _internal_set_context(::pg_query::CoercionContext value);
  public:

  // bool inout = 5 [json_name = "inout"];
  void clear_inout();
  bool inout() const;
  void set_inout(bool value);
  private:
  bool _internal_inout() const;
  void _internal_set_inout(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateCastStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::TypeName* sourcetype_;
  ::pg_query::TypeName* targettype_;
  ::pg_query::ObjectWithArgs* func_;
  int context_;
  bool inout_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateOpClassStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateOpClassStmt) */ {
 public:
  inline CreateOpClassStmt() : CreateOpClassStmt(nullptr) {}
  virtual ~CreateOpClassStmt();

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

  inline CreateOpClassStmt& operator=(const CreateOpClassStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateOpClassStmt& operator=(CreateOpClassStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateOpClassStmt& default_instance();

  static inline const CreateOpClassStmt* internal_default_instance() {
    return reinterpret_cast<const CreateOpClassStmt*>(
               &_CreateOpClassStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    123;

  friend void swap(CreateOpClassStmt& a, CreateOpClassStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateOpClassStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateOpClassStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateOpClassStmt* New() const final {
    return CreateMaybeMessage<CreateOpClassStmt>(nullptr);
  }

  CreateOpClassStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateOpClassStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateOpClassStmt& from);
  void MergeFrom(const CreateOpClassStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateOpClassStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateOpClassStmt";
  }
  protected:
  explicit CreateOpClassStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOpclassnameFieldNumber = 1,
    kOpfamilynameFieldNumber = 2,
    kItemsFieldNumber = 5,
    kAmnameFieldNumber = 3,
    kDatatypeFieldNumber = 4,
    kIsDefaultFieldNumber = 6,
  };
  // repeated .pg_query.Node opclassname = 1 [json_name = "opclassname"];
  int opclassname_size() const;
  private:
  int _internal_opclassname_size() const;
  public:
  void clear_opclassname();
  ::pg_query::Node* mutable_opclassname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_opclassname();
  private:
  const ::pg_query::Node& _internal_opclassname(int index) const;
  ::pg_query::Node* _internal_add_opclassname();
  public:
  const ::pg_query::Node& opclassname(int index) const;
  ::pg_query::Node* add_opclassname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      opclassname() const;

  // repeated .pg_query.Node opfamilyname = 2 [json_name = "opfamilyname"];
  int opfamilyname_size() const;
  private:
  int _internal_opfamilyname_size() const;
  public:
  void clear_opfamilyname();
  ::pg_query::Node* mutable_opfamilyname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_opfamilyname();
  private:
  const ::pg_query::Node& _internal_opfamilyname(int index) const;
  ::pg_query::Node* _internal_add_opfamilyname();
  public:
  const ::pg_query::Node& opfamilyname(int index) const;
  ::pg_query::Node* add_opfamilyname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      opfamilyname() const;

  // repeated .pg_query.Node items = 5 [json_name = "items"];
  int items_size() const;
  private:
  int _internal_items_size() const;
  public:
  void clear_items();
  ::pg_query::Node* mutable_items(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_items();
  private:
  const ::pg_query::Node& _internal_items(int index) const;
  ::pg_query::Node* _internal_add_items();
  public:
  const ::pg_query::Node& items(int index) const;
  ::pg_query::Node* add_items();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      items() const;

  // string amname = 3 [json_name = "amname"];
  void clear_amname();
  const std::string& amname() const;
  void set_amname(const std::string& value);
  void set_amname(std::string&& value);
  void set_amname(const char* value);
  void set_amname(const char* value, size_t size);
  std::string* mutable_amname();
  std::string* release_amname();
  void set_allocated_amname(std::string* amname);
  private:
  const std::string& _internal_amname() const;
  void _internal_set_amname(const std::string& value);
  std::string* _internal_mutable_amname();
  public:

  // .pg_query.TypeName datatype = 4 [json_name = "datatype"];
  bool has_datatype() const;
  private:
  bool _internal_has_datatype() const;
  public:
  void clear_datatype();
  const ::pg_query::TypeName& datatype() const;
  ::pg_query::TypeName* release_datatype();
  ::pg_query::TypeName* mutable_datatype();
  void set_allocated_datatype(::pg_query::TypeName* datatype);
  private:
  const ::pg_query::TypeName& _internal_datatype() const;
  ::pg_query::TypeName* _internal_mutable_datatype();
  public:
  void unsafe_arena_set_allocated_datatype(
      ::pg_query::TypeName* datatype);
  ::pg_query::TypeName* unsafe_arena_release_datatype();

  // bool is_default = 6 [json_name = "isDefault"];
  void clear_is_default();
  bool is_default() const;
  void set_is_default(bool value);
  private:
  bool _internal_is_default() const;
  void _internal_set_is_default(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateOpClassStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opclassname_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opfamilyname_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > items_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr amname_;
  ::pg_query::TypeName* datatype_;
  bool is_default_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateOpFamilyStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateOpFamilyStmt) */ {
 public:
  inline CreateOpFamilyStmt() : CreateOpFamilyStmt(nullptr) {}
  virtual ~CreateOpFamilyStmt();

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

  inline CreateOpFamilyStmt& operator=(const CreateOpFamilyStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateOpFamilyStmt& operator=(CreateOpFamilyStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateOpFamilyStmt& default_instance();

  static inline const CreateOpFamilyStmt* internal_default_instance() {
    return reinterpret_cast<const CreateOpFamilyStmt*>(
               &_CreateOpFamilyStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    124;

  friend void swap(CreateOpFamilyStmt& a, CreateOpFamilyStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateOpFamilyStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateOpFamilyStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateOpFamilyStmt* New() const final {
    return CreateMaybeMessage<CreateOpFamilyStmt>(nullptr);
  }

  CreateOpFamilyStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateOpFamilyStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateOpFamilyStmt& from);
  void MergeFrom(const CreateOpFamilyStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateOpFamilyStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateOpFamilyStmt";
  }
  protected:
  explicit CreateOpFamilyStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOpfamilynameFieldNumber = 1,
    kAmnameFieldNumber = 2,
  };
  // repeated .pg_query.Node opfamilyname = 1 [json_name = "opfamilyname"];
  int opfamilyname_size() const;
  private:
  int _internal_opfamilyname_size() const;
  public:
  void clear_opfamilyname();
  ::pg_query::Node* mutable_opfamilyname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_opfamilyname();
  private:
  const ::pg_query::Node& _internal_opfamilyname(int index) const;
  ::pg_query::Node* _internal_add_opfamilyname();
  public:
  const ::pg_query::Node& opfamilyname(int index) const;
  ::pg_query::Node* add_opfamilyname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      opfamilyname() const;

  // string amname = 2 [json_name = "amname"];
  void clear_amname();
  const std::string& amname() const;
  void set_amname(const std::string& value);
  void set_amname(std::string&& value);
  void set_amname(const char* value);
  void set_amname(const char* value, size_t size);
  std::string* mutable_amname();
  std::string* release_amname();
  void set_allocated_amname(std::string* amname);
  private:
  const std::string& _internal_amname() const;
  void _internal_set_amname(const std::string& value);
  std::string* _internal_mutable_amname();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateOpFamilyStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opfamilyname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr amname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterOpFamilyStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterOpFamilyStmt) */ {
 public:
  inline AlterOpFamilyStmt() : AlterOpFamilyStmt(nullptr) {}
  virtual ~AlterOpFamilyStmt();

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

  inline AlterOpFamilyStmt& operator=(const AlterOpFamilyStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterOpFamilyStmt& operator=(AlterOpFamilyStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterOpFamilyStmt& default_instance();

  static inline const AlterOpFamilyStmt* internal_default_instance() {
    return reinterpret_cast<const AlterOpFamilyStmt*>(
               &_AlterOpFamilyStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    125;

  friend void swap(AlterOpFamilyStmt& a, AlterOpFamilyStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterOpFamilyStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterOpFamilyStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterOpFamilyStmt* New() const final {
    return CreateMaybeMessage<AlterOpFamilyStmt>(nullptr);
  }

  AlterOpFamilyStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterOpFamilyStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterOpFamilyStmt& from);
  void MergeFrom(const AlterOpFamilyStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterOpFamilyStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterOpFamilyStmt";
  }
  protected:
  explicit AlterOpFamilyStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOpfamilynameFieldNumber = 1,
    kItemsFieldNumber = 4,
    kAmnameFieldNumber = 2,
    kIsDropFieldNumber = 3,
  };
  // repeated .pg_query.Node opfamilyname = 1 [json_name = "opfamilyname"];
  int opfamilyname_size() const;
  private:
  int _internal_opfamilyname_size() const;
  public:
  void clear_opfamilyname();
  ::pg_query::Node* mutable_opfamilyname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_opfamilyname();
  private:
  const ::pg_query::Node& _internal_opfamilyname(int index) const;
  ::pg_query::Node* _internal_add_opfamilyname();
  public:
  const ::pg_query::Node& opfamilyname(int index) const;
  ::pg_query::Node* add_opfamilyname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      opfamilyname() const;

  // repeated .pg_query.Node items = 4 [json_name = "items"];
  int items_size() const;
  private:
  int _internal_items_size() const;
  public:
  void clear_items();
  ::pg_query::Node* mutable_items(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_items();
  private:
  const ::pg_query::Node& _internal_items(int index) const;
  ::pg_query::Node* _internal_add_items();
  public:
  const ::pg_query::Node& items(int index) const;
  ::pg_query::Node* add_items();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      items() const;

  // string amname = 2 [json_name = "amname"];
  void clear_amname();
  const std::string& amname() const;
  void set_amname(const std::string& value);
  void set_amname(std::string&& value);
  void set_amname(const char* value);
  void set_amname(const char* value, size_t size);
  std::string* mutable_amname();
  std::string* release_amname();
  void set_allocated_amname(std::string* amname);
  private:
  const std::string& _internal_amname() const;
  void _internal_set_amname(const std::string& value);
  std::string* _internal_mutable_amname();
  public:

  // bool is_drop = 3 [json_name = "isDrop"];
  void clear_is_drop();
  bool is_drop() const;
  void set_is_drop(bool value);
  private:
  bool _internal_is_drop() const;
  void _internal_set_is_drop(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterOpFamilyStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opfamilyname_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > items_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr amname_;
  bool is_drop_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class PrepareStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PrepareStmt) */ {
 public:
  inline PrepareStmt() : PrepareStmt(nullptr) {}
  virtual ~PrepareStmt();

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

  inline PrepareStmt& operator=(const PrepareStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline PrepareStmt& operator=(PrepareStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PrepareStmt& default_instance();

  static inline const PrepareStmt* internal_default_instance() {
    return reinterpret_cast<const PrepareStmt*>(
               &_PrepareStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    126;

  friend void swap(PrepareStmt& a, PrepareStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(PrepareStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PrepareStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline PrepareStmt* New() const final {
    return CreateMaybeMessage<PrepareStmt>(nullptr);
  }

  PrepareStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PrepareStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PrepareStmt& from);
  void MergeFrom(const PrepareStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PrepareStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.PrepareStmt";
  }
  protected:
  explicit PrepareStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kArgtypesFieldNumber = 2,
    kNameFieldNumber = 1,
    kQueryFieldNumber = 3,
  };
  // repeated .pg_query.Node argtypes = 2 [json_name = "argtypes"];
  int argtypes_size() const;
  private:
  int _internal_argtypes_size() const;
  public:
  void clear_argtypes();
  ::pg_query::Node* mutable_argtypes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_argtypes();
  private:
  const ::pg_query::Node& _internal_argtypes(int index) const;
  ::pg_query::Node* _internal_add_argtypes();
  public:
  const ::pg_query::Node& argtypes(int index) const;
  ::pg_query::Node* add_argtypes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      argtypes() const;

  // string name = 1 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .pg_query.Node query = 3 [json_name = "query"];
  bool has_query() const;
  private:
  bool _internal_has_query() const;
  public:
  void clear_query();
  const ::pg_query::Node& query() const;
  ::pg_query::Node* release_query();
  ::pg_query::Node* mutable_query();
  void set_allocated_query(::pg_query::Node* query);
  private:
  const ::pg_query::Node& _internal_query() const;
  ::pg_query::Node* _internal_mutable_query();
  public:
  void unsafe_arena_set_allocated_query(
      ::pg_query::Node* query);
  ::pg_query::Node* unsafe_arena_release_query();

  // @@protoc_insertion_point(class_scope:pg_query.PrepareStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > argtypes_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::pg_query::Node* query_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ExecuteStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ExecuteStmt) */ {
 public:
  inline ExecuteStmt() : ExecuteStmt(nullptr) {}
  virtual ~ExecuteStmt();

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

  inline ExecuteStmt& operator=(const ExecuteStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExecuteStmt& operator=(ExecuteStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ExecuteStmt& default_instance();

  static inline const ExecuteStmt* internal_default_instance() {
    return reinterpret_cast<const ExecuteStmt*>(
               &_ExecuteStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    127;

  friend void swap(ExecuteStmt& a, ExecuteStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ExecuteStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ExecuteStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ExecuteStmt* New() const final {
    return CreateMaybeMessage<ExecuteStmt>(nullptr);
  }

  ExecuteStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ExecuteStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ExecuteStmt& from);
  void MergeFrom(const ExecuteStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ExecuteStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ExecuteStmt";
  }
  protected:
  explicit ExecuteStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kParamsFieldNumber = 2,
    kNameFieldNumber = 1,
  };
  // repeated .pg_query.Node params = 2 [json_name = "params"];
  int params_size() const;
  private:
  int _internal_params_size() const;
  public:
  void clear_params();
  ::pg_query::Node* mutable_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_params();
  private:
  const ::pg_query::Node& _internal_params(int index) const;
  ::pg_query::Node* _internal_add_params();
  public:
  const ::pg_query::Node& params(int index) const;
  ::pg_query::Node* add_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      params() const;

  // string name = 1 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ExecuteStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > params_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class DeallocateStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DeallocateStmt) */ {
 public:
  inline DeallocateStmt() : DeallocateStmt(nullptr) {}
  virtual ~DeallocateStmt();

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

  inline DeallocateStmt& operator=(const DeallocateStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeallocateStmt& operator=(DeallocateStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DeallocateStmt& default_instance();

  static inline const DeallocateStmt* internal_default_instance() {
    return reinterpret_cast<const DeallocateStmt*>(
               &_DeallocateStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    128;

  friend void swap(DeallocateStmt& a, DeallocateStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(DeallocateStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DeallocateStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline DeallocateStmt* New() const final {
    return CreateMaybeMessage<DeallocateStmt>(nullptr);
  }

  DeallocateStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeallocateStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DeallocateStmt& from);
  void MergeFrom(const DeallocateStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DeallocateStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DeallocateStmt";
  }
  protected:
  explicit DeallocateStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNameFieldNumber = 1,
  };
  // string name = 1 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.DeallocateStmt)
 private:
  class _Internal;

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

class DeclareCursorStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DeclareCursorStmt) */ {
 public:
  inline DeclareCursorStmt() : DeclareCursorStmt(nullptr) {}
  virtual ~DeclareCursorStmt();

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

  inline DeclareCursorStmt& operator=(const DeclareCursorStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeclareCursorStmt& operator=(DeclareCursorStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DeclareCursorStmt& default_instance();

  static inline const DeclareCursorStmt* internal_default_instance() {
    return reinterpret_cast<const DeclareCursorStmt*>(
               &_DeclareCursorStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    129;

  friend void swap(DeclareCursorStmt& a, DeclareCursorStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(DeclareCursorStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DeclareCursorStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline DeclareCursorStmt* New() const final {
    return CreateMaybeMessage<DeclareCursorStmt>(nullptr);
  }

  DeclareCursorStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeclareCursorStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DeclareCursorStmt& from);
  void MergeFrom(const DeclareCursorStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DeclareCursorStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DeclareCursorStmt";
  }
  protected:
  explicit DeclareCursorStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPortalnameFieldNumber = 1,
    kQueryFieldNumber = 3,
    kOptionsFieldNumber = 2,
  };
  // string portalname = 1 [json_name = "portalname"];
  void clear_portalname();
  const std::string& portalname() const;
  void set_portalname(const std::string& value);
  void set_portalname(std::string&& value);
  void set_portalname(const char* value);
  void set_portalname(const char* value, size_t size);
  std::string* mutable_portalname();
  std::string* release_portalname();
  void set_allocated_portalname(std::string* portalname);
  private:
  const std::string& _internal_portalname() const;
  void _internal_set_portalname(const std::string& value);
  std::string* _internal_mutable_portalname();
  public:

  // .pg_query.Node query = 3 [json_name = "query"];
  bool has_query() const;
  private:
  bool _internal_has_query() const;
  public:
  void clear_query();
  const ::pg_query::Node& query() const;
  ::pg_query::Node* release_query();
  ::pg_query::Node* mutable_query();
  void set_allocated_query(::pg_query::Node* query);
  private:
  const ::pg_query::Node& _internal_query() const;
  ::pg_query::Node* _internal_mutable_query();
  public:
  void unsafe_arena_set_allocated_query(
      ::pg_query::Node* query);
  ::pg_query::Node* unsafe_arena_release_query();

  // int32 options = 2 [json_name = "options"];
  void clear_options();
  ::PROTOBUF_NAMESPACE_ID::int32 options() const;
  void set_options(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_options() const;
  void _internal_set_options(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.DeclareCursorStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr portalname_;
  ::pg_query::Node* query_;
  ::PROTOBUF_NAMESPACE_ID::int32 options_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateTableSpaceStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateTableSpaceStmt) */ {
 public:
  inline CreateTableSpaceStmt() : CreateTableSpaceStmt(nullptr) {}
  virtual ~CreateTableSpaceStmt();

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

  inline CreateTableSpaceStmt& operator=(const CreateTableSpaceStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateTableSpaceStmt& operator=(CreateTableSpaceStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateTableSpaceStmt& default_instance();

  static inline const CreateTableSpaceStmt* internal_default_instance() {
    return reinterpret_cast<const CreateTableSpaceStmt*>(
               &_CreateTableSpaceStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    130;

  friend void swap(CreateTableSpaceStmt& a, CreateTableSpaceStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateTableSpaceStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateTableSpaceStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateTableSpaceStmt* New() const final {
    return CreateMaybeMessage<CreateTableSpaceStmt>(nullptr);
  }

  CreateTableSpaceStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateTableSpaceStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateTableSpaceStmt& from);
  void MergeFrom(const CreateTableSpaceStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateTableSpaceStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateTableSpaceStmt";
  }
  protected:
  explicit CreateTableSpaceStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 4,
    kTablespacenameFieldNumber = 1,
    kLocationFieldNumber = 3,
    kOwnerFieldNumber = 2,
  };
  // repeated .pg_query.Node options = 4 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string tablespacename = 1 [json_name = "tablespacename"];
  void clear_tablespacename();
  const std::string& tablespacename() const;
  void set_tablespacename(const std::string& value);
  void set_tablespacename(std::string&& value);
  void set_tablespacename(const char* value);
  void set_tablespacename(const char* value, size_t size);
  std::string* mutable_tablespacename();
  std::string* release_tablespacename();
  void set_allocated_tablespacename(std::string* tablespacename);
  private:
  const std::string& _internal_tablespacename() const;
  void _internal_set_tablespacename(const std::string& value);
  std::string* _internal_mutable_tablespacename();
  public:

  // string location = 3 [json_name = "location"];
  void clear_location();
  const std::string& location() const;
  void set_location(const std::string& value);
  void set_location(std::string&& value);
  void set_location(const char* value);
  void set_location(const char* value, size_t size);
  std::string* mutable_location();
  std::string* release_location();
  void set_allocated_location(std::string* location);
  private:
  const std::string& _internal_location() const;
  void _internal_set_location(const std::string& value);
  std::string* _internal_mutable_location();
  public:

  // .pg_query.RoleSpec owner = 2 [json_name = "owner"];
  bool has_owner() const;
  private:
  bool _internal_has_owner() const;
  public:
  void clear_owner();
  const ::pg_query::RoleSpec& owner() const;
  ::pg_query::RoleSpec* release_owner();
  ::pg_query::RoleSpec* mutable_owner();
  void set_allocated_owner(::pg_query::RoleSpec* owner);
  private:
  const ::pg_query::RoleSpec& _internal_owner() const;
  ::pg_query::RoleSpec* _internal_mutable_owner();
  public:
  void unsafe_arena_set_allocated_owner(
      ::pg_query::RoleSpec* owner);
  ::pg_query::RoleSpec* unsafe_arena_release_owner();

  // @@protoc_insertion_point(class_scope:pg_query.CreateTableSpaceStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tablespacename_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr location_;
  ::pg_query::RoleSpec* owner_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class DropTableSpaceStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropTableSpaceStmt) */ {
 public:
  inline DropTableSpaceStmt() : DropTableSpaceStmt(nullptr) {}
  virtual ~DropTableSpaceStmt();

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

  inline DropTableSpaceStmt& operator=(const DropTableSpaceStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline DropTableSpaceStmt& operator=(DropTableSpaceStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DropTableSpaceStmt& default_instance();

  static inline const DropTableSpaceStmt* internal_default_instance() {
    return reinterpret_cast<const DropTableSpaceStmt*>(
               &_DropTableSpaceStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    131;

  friend void swap(DropTableSpaceStmt& a, DropTableSpaceStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(DropTableSpaceStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DropTableSpaceStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline DropTableSpaceStmt* New() const final {
    return CreateMaybeMessage<DropTableSpaceStmt>(nullptr);
  }

  DropTableSpaceStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DropTableSpaceStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DropTableSpaceStmt& from);
  void MergeFrom(const DropTableSpaceStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DropTableSpaceStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DropTableSpaceStmt";
  }
  protected:
  explicit DropTableSpaceStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTablespacenameFieldNumber = 1,
    kMissingOkFieldNumber = 2,
  };
  // string tablespacename = 1 [json_name = "tablespacename"];
  void clear_tablespacename();
  const std::string& tablespacename() const;
  void set_tablespacename(const std::string& value);
  void set_tablespacename(std::string&& value);
  void set_tablespacename(const char* value);
  void set_tablespacename(const char* value, size_t size);
  std::string* mutable_tablespacename();
  std::string* release_tablespacename();
  void set_allocated_tablespacename(std::string* tablespacename);
  private:
  const std::string& _internal_tablespacename() const;
  void _internal_set_tablespacename(const std::string& value);
  std::string* _internal_mutable_tablespacename();
  public:

  // bool missing_ok = 2 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.DropTableSpaceStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tablespacename_;
  bool missing_ok_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterObjectDependsStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterObjectDependsStmt) */ {
 public:
  inline AlterObjectDependsStmt() : AlterObjectDependsStmt(nullptr) {}
  virtual ~AlterObjectDependsStmt();

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

  inline AlterObjectDependsStmt& operator=(const AlterObjectDependsStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterObjectDependsStmt& operator=(AlterObjectDependsStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterObjectDependsStmt& default_instance();

  static inline const AlterObjectDependsStmt* internal_default_instance() {
    return reinterpret_cast<const AlterObjectDependsStmt*>(
               &_AlterObjectDependsStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    132;

  friend void swap(AlterObjectDependsStmt& a, AlterObjectDependsStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterObjectDependsStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterObjectDependsStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterObjectDependsStmt* New() const final {
    return CreateMaybeMessage<AlterObjectDependsStmt>(nullptr);
  }

  AlterObjectDependsStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterObjectDependsStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterObjectDependsStmt& from);
  void MergeFrom(const AlterObjectDependsStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterObjectDependsStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterObjectDependsStmt";
  }
  protected:
  explicit AlterObjectDependsStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRelationFieldNumber = 2,
    kObjectFieldNumber = 3,
    kExtnameFieldNumber = 4,
    kObjectTypeFieldNumber = 1,
    kRemoveFieldNumber = 5,
  };
  // .pg_query.RangeVar relation = 2 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.Node object = 3 [json_name = "object"];
  bool has_object() const;
  private:
  bool _internal_has_object() const;
  public:
  void clear_object();
  const ::pg_query::Node& object() const;
  ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* object);
  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();
  public:
  void unsafe_arena_set_allocated_object(
      ::pg_query::Node* object);
  ::pg_query::Node* unsafe_arena_release_object();

  // .pg_query.Node extname = 4 [json_name = "extname"];
  bool has_extname() const;
  private:
  bool _internal_has_extname() const;
  public:
  void clear_extname();
  const ::pg_query::Node& extname() const;
  ::pg_query::Node* release_extname();
  ::pg_query::Node* mutable_extname();
  void set_allocated_extname(::pg_query::Node* extname);
  private:
  const ::pg_query::Node& _internal_extname() const;
  ::pg_query::Node* _internal_mutable_extname();
  public:
  void unsafe_arena_set_allocated_extname(
      ::pg_query::Node* extname);
  ::pg_query::Node* unsafe_arena_release_extname();

  // .pg_query.ObjectType object_type = 1 [json_name = "objectType"];
  void clear_object_type();
  ::pg_query::ObjectType object_type() const;
  void set_object_type(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_object_type() const;
  void _internal_set_object_type(::pg_query::ObjectType value);
  public:

  // bool remove = 5 [json_name = "remove"];
  void clear_remove();
  bool remove() const;
  void set_remove(bool value);
  private:
  bool _internal_remove() const;
  void _internal_set_remove(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterObjectDependsStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::RangeVar* relation_;
  ::pg_query::Node* object_;
  ::pg_query::Node* extname_;
  int object_type_;
  bool remove_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterObjectSchemaStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterObjectSchemaStmt) */ {
 public:
  inline AlterObjectSchemaStmt() : AlterObjectSchemaStmt(nullptr) {}
  virtual ~AlterObjectSchemaStmt();

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

  inline AlterObjectSchemaStmt& operator=(const AlterObjectSchemaStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterObjectSchemaStmt& operator=(AlterObjectSchemaStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterObjectSchemaStmt& default_instance();

  static inline const AlterObjectSchemaStmt* internal_default_instance() {
    return reinterpret_cast<const AlterObjectSchemaStmt*>(
               &_AlterObjectSchemaStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    133;

  friend void swap(AlterObjectSchemaStmt& a, AlterObjectSchemaStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterObjectSchemaStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterObjectSchemaStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterObjectSchemaStmt* New() const final {
    return CreateMaybeMessage<AlterObjectSchemaStmt>(nullptr);
  }

  AlterObjectSchemaStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterObjectSchemaStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterObjectSchemaStmt& from);
  void MergeFrom(const AlterObjectSchemaStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterObjectSchemaStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterObjectSchemaStmt";
  }
  protected:
  explicit AlterObjectSchemaStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNewschemaFieldNumber = 4,
    kRelationFieldNumber = 2,
    kObjectFieldNumber = 3,
    kObjectTypeFieldNumber = 1,
    kMissingOkFieldNumber = 5,
  };
  // string newschema = 4 [json_name = "newschema"];
  void clear_newschema();
  const std::string& newschema() const;
  void set_newschema(const std::string& value);
  void set_newschema(std::string&& value);
  void set_newschema(const char* value);
  void set_newschema(const char* value, size_t size);
  std::string* mutable_newschema();
  std::string* release_newschema();
  void set_allocated_newschema(std::string* newschema);
  private:
  const std::string& _internal_newschema() const;
  void _internal_set_newschema(const std::string& value);
  std::string* _internal_mutable_newschema();
  public:

  // .pg_query.RangeVar relation = 2 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.Node object = 3 [json_name = "object"];
  bool has_object() const;
  private:
  bool _internal_has_object() const;
  public:
  void clear_object();
  const ::pg_query::Node& object() const;
  ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* object);
  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();
  public:
  void unsafe_arena_set_allocated_object(
      ::pg_query::Node* object);
  ::pg_query::Node* unsafe_arena_release_object();

  // .pg_query.ObjectType object_type = 1 [json_name = "objectType"];
  void clear_object_type();
  ::pg_query::ObjectType object_type() const;
  void set_object_type(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_object_type() const;
  void _internal_set_object_type(::pg_query::ObjectType value);
  public:

  // bool missing_ok = 5 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterObjectSchemaStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newschema_;
  ::pg_query::RangeVar* relation_;
  ::pg_query::Node* object_;
  int object_type_;
  bool missing_ok_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterOwnerStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterOwnerStmt) */ {
 public:
  inline AlterOwnerStmt() : AlterOwnerStmt(nullptr) {}
  virtual ~AlterOwnerStmt();

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

  inline AlterOwnerStmt& operator=(const AlterOwnerStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterOwnerStmt& operator=(AlterOwnerStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterOwnerStmt& default_instance();

  static inline const AlterOwnerStmt* internal_default_instance() {
    return reinterpret_cast<const AlterOwnerStmt*>(
               &_AlterOwnerStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    134;

  friend void swap(AlterOwnerStmt& a, AlterOwnerStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterOwnerStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterOwnerStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterOwnerStmt* New() const final {
    return CreateMaybeMessage<AlterOwnerStmt>(nullptr);
  }

  AlterOwnerStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterOwnerStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterOwnerStmt& from);
  void MergeFrom(const AlterOwnerStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterOwnerStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterOwnerStmt";
  }
  protected:
  explicit AlterOwnerStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRelationFieldNumber = 2,
    kObjectFieldNumber = 3,
    kNewownerFieldNumber = 4,
    kObjectTypeFieldNumber = 1,
  };
  // .pg_query.RangeVar relation = 2 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // .pg_query.Node object = 3 [json_name = "object"];
  bool has_object() const;
  private:
  bool _internal_has_object() const;
  public:
  void clear_object();
  const ::pg_query::Node& object() const;
  ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* object);
  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();
  public:
  void unsafe_arena_set_allocated_object(
      ::pg_query::Node* object);
  ::pg_query::Node* unsafe_arena_release_object();

  // .pg_query.RoleSpec newowner = 4 [json_name = "newowner"];
  bool has_newowner() const;
  private:
  bool _internal_has_newowner() const;
  public:
  void clear_newowner();
  const ::pg_query::RoleSpec& newowner() const;
  ::pg_query::RoleSpec* release_newowner();
  ::pg_query::RoleSpec* mutable_newowner();
  void set_allocated_newowner(::pg_query::RoleSpec* newowner);
  private:
  const ::pg_query::RoleSpec& _internal_newowner() const;
  ::pg_query::RoleSpec* _internal_mutable_newowner();
  public:
  void unsafe_arena_set_allocated_newowner(
      ::pg_query::RoleSpec* newowner);
  ::pg_query::RoleSpec* unsafe_arena_release_newowner();

  // .pg_query.ObjectType object_type = 1 [json_name = "objectType"];
  void clear_object_type();
  ::pg_query::ObjectType object_type() const;
  void set_object_type(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_object_type() const;
  void _internal_set_object_type(::pg_query::ObjectType value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterOwnerStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::RangeVar* relation_;
  ::pg_query::Node* object_;
  ::pg_query::RoleSpec* newowner_;
  int object_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterOperatorStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterOperatorStmt) */ {
 public:
  inline AlterOperatorStmt() : AlterOperatorStmt(nullptr) {}
  virtual ~AlterOperatorStmt();

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

  inline AlterOperatorStmt& operator=(const AlterOperatorStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterOperatorStmt& operator=(AlterOperatorStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterOperatorStmt& default_instance();

  static inline const AlterOperatorStmt* internal_default_instance() {
    return reinterpret_cast<const AlterOperatorStmt*>(
               &_AlterOperatorStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    135;

  friend void swap(AlterOperatorStmt& a, AlterOperatorStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterOperatorStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterOperatorStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterOperatorStmt* New() const final {
    return CreateMaybeMessage<AlterOperatorStmt>(nullptr);
  }

  AlterOperatorStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterOperatorStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterOperatorStmt& from);
  void MergeFrom(const AlterOperatorStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterOperatorStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterOperatorStmt";
  }
  protected:
  explicit AlterOperatorStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 2,
    kOpernameFieldNumber = 1,
  };
  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // .pg_query.ObjectWithArgs opername = 1 [json_name = "opername"];
  bool has_opername() const;
  private:
  bool _internal_has_opername() const;
  public:
  void clear_opername();
  const ::pg_query::ObjectWithArgs& opername() const;
  ::pg_query::ObjectWithArgs* release_opername();
  ::pg_query::ObjectWithArgs* mutable_opername();
  void set_allocated_opername(::pg_query::ObjectWithArgs* opername);
  private:
  const ::pg_query::ObjectWithArgs& _internal_opername() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_opername();
  public:
  void unsafe_arena_set_allocated_opername(
      ::pg_query::ObjectWithArgs* opername);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_opername();

  // @@protoc_insertion_point(class_scope:pg_query.AlterOperatorStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::pg_query::ObjectWithArgs* opername_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterTypeStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTypeStmt) */ {
 public:
  inline AlterTypeStmt() : AlterTypeStmt(nullptr) {}
  virtual ~AlterTypeStmt();

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

  inline AlterTypeStmt& operator=(const AlterTypeStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterTypeStmt& operator=(AlterTypeStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterTypeStmt& default_instance();

  static inline const AlterTypeStmt* internal_default_instance() {
    return reinterpret_cast<const AlterTypeStmt*>(
               &_AlterTypeStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    136;

  friend void swap(AlterTypeStmt& a, AlterTypeStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterTypeStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterTypeStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterTypeStmt* New() const final {
    return CreateMaybeMessage<AlterTypeStmt>(nullptr);
  }

  AlterTypeStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterTypeStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterTypeStmt& from);
  void MergeFrom(const AlterTypeStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterTypeStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterTypeStmt";
  }
  protected:
  explicit AlterTypeStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTypeNameFieldNumber = 1,
    kOptionsFieldNumber = 2,
  };
  // repeated .pg_query.Node type_name = 1 [json_name = "typeName"];
  int type_name_size() const;
  private:
  int _internal_type_name_size() const;
  public:
  void clear_type_name();
  ::pg_query::Node* mutable_type_name(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_type_name();
  private:
  const ::pg_query::Node& _internal_type_name(int index) const;
  ::pg_query::Node* _internal_add_type_name();
  public:
  const ::pg_query::Node& type_name(int index) const;
  ::pg_query::Node* add_type_name();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      type_name() const;

  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // @@protoc_insertion_point(class_scope:pg_query.AlterTypeStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > type_name_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class DropOwnedStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropOwnedStmt) */ {
 public:
  inline DropOwnedStmt() : DropOwnedStmt(nullptr) {}
  virtual ~DropOwnedStmt();

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

  inline DropOwnedStmt& operator=(const DropOwnedStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline DropOwnedStmt& operator=(DropOwnedStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DropOwnedStmt& default_instance();

  static inline const DropOwnedStmt* internal_default_instance() {
    return reinterpret_cast<const DropOwnedStmt*>(
               &_DropOwnedStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    137;

  friend void swap(DropOwnedStmt& a, DropOwnedStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(DropOwnedStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DropOwnedStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline DropOwnedStmt* New() const final {
    return CreateMaybeMessage<DropOwnedStmt>(nullptr);
  }

  DropOwnedStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DropOwnedStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DropOwnedStmt& from);
  void MergeFrom(const DropOwnedStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DropOwnedStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DropOwnedStmt";
  }
  protected:
  explicit DropOwnedStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRolesFieldNumber = 1,
    kBehaviorFieldNumber = 2,
  };
  // repeated .pg_query.Node roles = 1 [json_name = "roles"];
  int roles_size() const;
  private:
  int _internal_roles_size() const;
  public:
  void clear_roles();
  ::pg_query::Node* mutable_roles(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_roles();
  private:
  const ::pg_query::Node& _internal_roles(int index) const;
  ::pg_query::Node* _internal_add_roles();
  public:
  const ::pg_query::Node& roles(int index) const;
  ::pg_query::Node* add_roles();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      roles() const;

  // .pg_query.DropBehavior behavior = 2 [json_name = "behavior"];
  void clear_behavior();
  ::pg_query::DropBehavior behavior() const;
  void set_behavior(::pg_query::DropBehavior value);
  private:
  ::pg_query::DropBehavior _internal_behavior() const;
  void _internal_set_behavior(::pg_query::DropBehavior value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.DropOwnedStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > roles_;
  int behavior_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ReassignOwnedStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ReassignOwnedStmt) */ {
 public:
  inline ReassignOwnedStmt() : ReassignOwnedStmt(nullptr) {}
  virtual ~ReassignOwnedStmt();

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

  inline ReassignOwnedStmt& operator=(const ReassignOwnedStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReassignOwnedStmt& operator=(ReassignOwnedStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ReassignOwnedStmt& default_instance();

  static inline const ReassignOwnedStmt* internal_default_instance() {
    return reinterpret_cast<const ReassignOwnedStmt*>(
               &_ReassignOwnedStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    138;

  friend void swap(ReassignOwnedStmt& a, ReassignOwnedStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ReassignOwnedStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ReassignOwnedStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ReassignOwnedStmt* New() const final {
    return CreateMaybeMessage<ReassignOwnedStmt>(nullptr);
  }

  ReassignOwnedStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ReassignOwnedStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ReassignOwnedStmt& from);
  void MergeFrom(const ReassignOwnedStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReassignOwnedStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ReassignOwnedStmt";
  }
  protected:
  explicit ReassignOwnedStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRolesFieldNumber = 1,
    kNewroleFieldNumber = 2,
  };
  // repeated .pg_query.Node roles = 1 [json_name = "roles"];
  int roles_size() const;
  private:
  int _internal_roles_size() const;
  public:
  void clear_roles();
  ::pg_query::Node* mutable_roles(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_roles();
  private:
  const ::pg_query::Node& _internal_roles(int index) const;
  ::pg_query::Node* _internal_add_roles();
  public:
  const ::pg_query::Node& roles(int index) const;
  ::pg_query::Node* add_roles();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      roles() const;

  // .pg_query.RoleSpec newrole = 2 [json_name = "newrole"];
  bool has_newrole() const;
  private:
  bool _internal_has_newrole() const;
  public:
  void clear_newrole();
  const ::pg_query::RoleSpec& newrole() const;
  ::pg_query::RoleSpec* release_newrole();
  ::pg_query::RoleSpec* mutable_newrole();
  void set_allocated_newrole(::pg_query::RoleSpec* newrole);
  private:
  const ::pg_query::RoleSpec& _internal_newrole() const;
  ::pg_query::RoleSpec* _internal_mutable_newrole();
  public:
  void unsafe_arena_set_allocated_newrole(
      ::pg_query::RoleSpec* newrole);
  ::pg_query::RoleSpec* unsafe_arena_release_newrole();

  // @@protoc_insertion_point(class_scope:pg_query.ReassignOwnedStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > roles_;
  ::pg_query::RoleSpec* newrole_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CompositeTypeStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CompositeTypeStmt) */ {
 public:
  inline CompositeTypeStmt() : CompositeTypeStmt(nullptr) {}
  virtual ~CompositeTypeStmt();

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

  inline CompositeTypeStmt& operator=(const CompositeTypeStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CompositeTypeStmt& operator=(CompositeTypeStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CompositeTypeStmt& default_instance();

  static inline const CompositeTypeStmt* internal_default_instance() {
    return reinterpret_cast<const CompositeTypeStmt*>(
               &_CompositeTypeStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    139;

  friend void swap(CompositeTypeStmt& a, CompositeTypeStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CompositeTypeStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CompositeTypeStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CompositeTypeStmt* New() const final {
    return CreateMaybeMessage<CompositeTypeStmt>(nullptr);
  }

  CompositeTypeStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CompositeTypeStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CompositeTypeStmt& from);
  void MergeFrom(const CompositeTypeStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CompositeTypeStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CompositeTypeStmt";
  }
  protected:
  explicit CompositeTypeStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kColdeflistFieldNumber = 2,
    kTypevarFieldNumber = 1,
  };
  // repeated .pg_query.Node coldeflist = 2 [json_name = "coldeflist"];
  int coldeflist_size() const;
  private:
  int _internal_coldeflist_size() const;
  public:
  void clear_coldeflist();
  ::pg_query::Node* mutable_coldeflist(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_coldeflist();
  private:
  const ::pg_query::Node& _internal_coldeflist(int index) const;
  ::pg_query::Node* _internal_add_coldeflist();
  public:
  const ::pg_query::Node& coldeflist(int index) const;
  ::pg_query::Node* add_coldeflist();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      coldeflist() const;

  // .pg_query.RangeVar typevar = 1 [json_name = "typevar"];
  bool has_typevar() const;
  private:
  bool _internal_has_typevar() const;
  public:
  void clear_typevar();
  const ::pg_query::RangeVar& typevar() const;
  ::pg_query::RangeVar* release_typevar();
  ::pg_query::RangeVar* mutable_typevar();
  void set_allocated_typevar(::pg_query::RangeVar* typevar);
  private:
  const ::pg_query::RangeVar& _internal_typevar() const;
  ::pg_query::RangeVar* _internal_mutable_typevar();
  public:
  void unsafe_arena_set_allocated_typevar(
      ::pg_query::RangeVar* typevar);
  ::pg_query::RangeVar* unsafe_arena_release_typevar();

  // @@protoc_insertion_point(class_scope:pg_query.CompositeTypeStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coldeflist_;
  ::pg_query::RangeVar* typevar_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateEnumStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateEnumStmt) */ {
 public:
  inline CreateEnumStmt() : CreateEnumStmt(nullptr) {}
  virtual ~CreateEnumStmt();

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

  inline CreateEnumStmt& operator=(const CreateEnumStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateEnumStmt& operator=(CreateEnumStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateEnumStmt& default_instance();

  static inline const CreateEnumStmt* internal_default_instance() {
    return reinterpret_cast<const CreateEnumStmt*>(
               &_CreateEnumStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    140;

  friend void swap(CreateEnumStmt& a, CreateEnumStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateEnumStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateEnumStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateEnumStmt* New() const final {
    return CreateMaybeMessage<CreateEnumStmt>(nullptr);
  }

  CreateEnumStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateEnumStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateEnumStmt& from);
  void MergeFrom(const CreateEnumStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateEnumStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateEnumStmt";
  }
  protected:
  explicit CreateEnumStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTypeNameFieldNumber = 1,
    kValsFieldNumber = 2,
  };
  // repeated .pg_query.Node type_name = 1 [json_name = "typeName"];
  int type_name_size() const;
  private:
  int _internal_type_name_size() const;
  public:
  void clear_type_name();
  ::pg_query::Node* mutable_type_name(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_type_name();
  private:
  const ::pg_query::Node& _internal_type_name(int index) const;
  ::pg_query::Node* _internal_add_type_name();
  public:
  const ::pg_query::Node& type_name(int index) const;
  ::pg_query::Node* add_type_name();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      type_name() const;

  // repeated .pg_query.Node vals = 2 [json_name = "vals"];
  int vals_size() const;
  private:
  int _internal_vals_size() const;
  public:
  void clear_vals();
  ::pg_query::Node* mutable_vals(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_vals();
  private:
  const ::pg_query::Node& _internal_vals(int index) const;
  ::pg_query::Node* _internal_add_vals();
  public:
  const ::pg_query::Node& vals(int index) const;
  ::pg_query::Node* add_vals();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      vals() const;

  // @@protoc_insertion_point(class_scope:pg_query.CreateEnumStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > type_name_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > vals_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateRangeStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateRangeStmt) */ {
 public:
  inline CreateRangeStmt() : CreateRangeStmt(nullptr) {}
  virtual ~CreateRangeStmt();

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

  inline CreateRangeStmt& operator=(const CreateRangeStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateRangeStmt& operator=(CreateRangeStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateRangeStmt& default_instance();

  static inline const CreateRangeStmt* internal_default_instance() {
    return reinterpret_cast<const CreateRangeStmt*>(
               &_CreateRangeStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    141;

  friend void swap(CreateRangeStmt& a, CreateRangeStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateRangeStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateRangeStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateRangeStmt* New() const final {
    return CreateMaybeMessage<CreateRangeStmt>(nullptr);
  }

  CreateRangeStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateRangeStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateRangeStmt& from);
  void MergeFrom(const CreateRangeStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateRangeStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateRangeStmt";
  }
  protected:
  explicit CreateRangeStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTypeNameFieldNumber = 1,
    kParamsFieldNumber = 2,
  };
  // repeated .pg_query.Node type_name = 1 [json_name = "typeName"];
  int type_name_size() const;
  private:
  int _internal_type_name_size() const;
  public:
  void clear_type_name();
  ::pg_query::Node* mutable_type_name(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_type_name();
  private:
  const ::pg_query::Node& _internal_type_name(int index) const;
  ::pg_query::Node* _internal_add_type_name();
  public:
  const ::pg_query::Node& type_name(int index) const;
  ::pg_query::Node* add_type_name();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      type_name() const;

  // repeated .pg_query.Node params = 2 [json_name = "params"];
  int params_size() const;
  private:
  int _internal_params_size() const;
  public:
  void clear_params();
  ::pg_query::Node* mutable_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_params();
  private:
  const ::pg_query::Node& _internal_params(int index) const;
  ::pg_query::Node* _internal_add_params();
  public:
  const ::pg_query::Node& params(int index) const;
  ::pg_query::Node* add_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      params() const;

  // @@protoc_insertion_point(class_scope:pg_query.CreateRangeStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > type_name_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > params_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterEnumStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterEnumStmt) */ {
 public:
  inline AlterEnumStmt() : AlterEnumStmt(nullptr) {}
  virtual ~AlterEnumStmt();

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

  inline AlterEnumStmt& operator=(const AlterEnumStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterEnumStmt& operator=(AlterEnumStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterEnumStmt& default_instance();

  static inline const AlterEnumStmt* internal_default_instance() {
    return reinterpret_cast<const AlterEnumStmt*>(
               &_AlterEnumStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    142;

  friend void swap(AlterEnumStmt& a, AlterEnumStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterEnumStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterEnumStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterEnumStmt* New() const final {
    return CreateMaybeMessage<AlterEnumStmt>(nullptr);
  }

  AlterEnumStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterEnumStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterEnumStmt& from);
  void MergeFrom(const AlterEnumStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterEnumStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterEnumStmt";
  }
  protected:
  explicit AlterEnumStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTypeNameFieldNumber = 1,
    kOldValFieldNumber = 2,
    kNewValFieldNumber = 3,
    kNewValNeighborFieldNumber = 4,
    kNewValIsAfterFieldNumber = 5,
    kSkipIfNewValExistsFieldNumber = 6,
  };
  // repeated .pg_query.Node type_name = 1 [json_name = "typeName"];
  int type_name_size() const;
  private:
  int _internal_type_name_size() const;
  public:
  void clear_type_name();
  ::pg_query::Node* mutable_type_name(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_type_name();
  private:
  const ::pg_query::Node& _internal_type_name(int index) const;
  ::pg_query::Node* _internal_add_type_name();
  public:
  const ::pg_query::Node& type_name(int index) const;
  ::pg_query::Node* add_type_name();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      type_name() const;

  // string old_val = 2 [json_name = "oldVal"];
  void clear_old_val();
  const std::string& old_val() const;
  void set_old_val(const std::string& value);
  void set_old_val(std::string&& value);
  void set_old_val(const char* value);
  void set_old_val(const char* value, size_t size);
  std::string* mutable_old_val();
  std::string* release_old_val();
  void set_allocated_old_val(std::string* old_val);
  private:
  const std::string& _internal_old_val() const;
  void _internal_set_old_val(const std::string& value);
  std::string* _internal_mutable_old_val();
  public:

  // string new_val = 3 [json_name = "newVal"];
  void clear_new_val();
  const std::string& new_val() const;
  void set_new_val(const std::string& value);
  void set_new_val(std::string&& value);
  void set_new_val(const char* value);
  void set_new_val(const char* value, size_t size);
  std::string* mutable_new_val();
  std::string* release_new_val();
  void set_allocated_new_val(std::string* new_val);
  private:
  const std::string& _internal_new_val() const;
  void _internal_set_new_val(const std::string& value);
  std::string* _internal_mutable_new_val();
  public:

  // string new_val_neighbor = 4 [json_name = "newValNeighbor"];
  void clear_new_val_neighbor();
  const std::string& new_val_neighbor() const;
  void set_new_val_neighbor(const std::string& value);
  void set_new_val_neighbor(std::string&& value);
  void set_new_val_neighbor(const char* value);
  void set_new_val_neighbor(const char* value, size_t size);
  std::string* mutable_new_val_neighbor();
  std::string* release_new_val_neighbor();
  void set_allocated_new_val_neighbor(std::string* new_val_neighbor);
  private:
  const std::string& _internal_new_val_neighbor() const;
  void _internal_set_new_val_neighbor(const std::string& value);
  std::string* _internal_mutable_new_val_neighbor();
  public:

  // bool new_val_is_after = 5 [json_name = "newValIsAfter"];
  void clear_new_val_is_after();
  bool new_val_is_after() const;
  void set_new_val_is_after(bool value);
  private:
  bool _internal_new_val_is_after() const;
  void _internal_set_new_val_is_after(bool value);
  public:

  // bool skip_if_new_val_exists = 6 [json_name = "skipIfNewValExists"];
  void clear_skip_if_new_val_exists();
  bool skip_if_new_val_exists() const;
  void set_skip_if_new_val_exists(bool value);
  private:
  bool _internal_skip_if_new_val_exists() const;
  void _internal_set_skip_if_new_val_exists(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterEnumStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > type_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr old_val_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr new_val_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr new_val_neighbor_;
  bool new_val_is_after_;
  bool skip_if_new_val_exists_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterTSDictionaryStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTSDictionaryStmt) */ {
 public:
  inline AlterTSDictionaryStmt() : AlterTSDictionaryStmt(nullptr) {}
  virtual ~AlterTSDictionaryStmt();

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

  inline AlterTSDictionaryStmt& operator=(const AlterTSDictionaryStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterTSDictionaryStmt& operator=(AlterTSDictionaryStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterTSDictionaryStmt& default_instance();

  static inline const AlterTSDictionaryStmt* internal_default_instance() {
    return reinterpret_cast<const AlterTSDictionaryStmt*>(
               &_AlterTSDictionaryStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    143;

  friend void swap(AlterTSDictionaryStmt& a, AlterTSDictionaryStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterTSDictionaryStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterTSDictionaryStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterTSDictionaryStmt* New() const final {
    return CreateMaybeMessage<AlterTSDictionaryStmt>(nullptr);
  }

  AlterTSDictionaryStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterTSDictionaryStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterTSDictionaryStmt& from);
  void MergeFrom(const AlterTSDictionaryStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterTSDictionaryStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterTSDictionaryStmt";
  }
  protected:
  explicit AlterTSDictionaryStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDictnameFieldNumber = 1,
    kOptionsFieldNumber = 2,
  };
  // repeated .pg_query.Node dictname = 1 [json_name = "dictname"];
  int dictname_size() const;
  private:
  int _internal_dictname_size() const;
  public:
  void clear_dictname();
  ::pg_query::Node* mutable_dictname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_dictname();
  private:
  const ::pg_query::Node& _internal_dictname(int index) const;
  ::pg_query::Node* _internal_add_dictname();
  public:
  const ::pg_query::Node& dictname(int index) const;
  ::pg_query::Node* add_dictname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      dictname() const;

  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // @@protoc_insertion_point(class_scope:pg_query.AlterTSDictionaryStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > dictname_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterTSConfigurationStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTSConfigurationStmt) */ {
 public:
  inline AlterTSConfigurationStmt() : AlterTSConfigurationStmt(nullptr) {}
  virtual ~AlterTSConfigurationStmt();

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

  inline AlterTSConfigurationStmt& operator=(const AlterTSConfigurationStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterTSConfigurationStmt& operator=(AlterTSConfigurationStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterTSConfigurationStmt& default_instance();

  static inline const AlterTSConfigurationStmt* internal_default_instance() {
    return reinterpret_cast<const AlterTSConfigurationStmt*>(
               &_AlterTSConfigurationStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    144;

  friend void swap(AlterTSConfigurationStmt& a, AlterTSConfigurationStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterTSConfigurationStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterTSConfigurationStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterTSConfigurationStmt* New() const final {
    return CreateMaybeMessage<AlterTSConfigurationStmt>(nullptr);
  }

  AlterTSConfigurationStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterTSConfigurationStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterTSConfigurationStmt& from);
  void MergeFrom(const AlterTSConfigurationStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterTSConfigurationStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterTSConfigurationStmt";
  }
  protected:
  explicit AlterTSConfigurationStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCfgnameFieldNumber = 2,
    kTokentypeFieldNumber = 3,
    kDictsFieldNumber = 4,
    kKindFieldNumber = 1,
    kOverrideFieldNumber = 5,
    kReplaceFieldNumber = 6,
    kMissingOkFieldNumber = 7,
  };
  // repeated .pg_query.Node cfgname = 2 [json_name = "cfgname"];
  int cfgname_size() const;
  private:
  int _internal_cfgname_size() const;
  public:
  void clear_cfgname();
  ::pg_query::Node* mutable_cfgname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_cfgname();
  private:
  const ::pg_query::Node& _internal_cfgname(int index) const;
  ::pg_query::Node* _internal_add_cfgname();
  public:
  const ::pg_query::Node& cfgname(int index) const;
  ::pg_query::Node* add_cfgname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      cfgname() const;

  // repeated .pg_query.Node tokentype = 3 [json_name = "tokentype"];
  int tokentype_size() const;
  private:
  int _internal_tokentype_size() const;
  public:
  void clear_tokentype();
  ::pg_query::Node* mutable_tokentype(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_tokentype();
  private:
  const ::pg_query::Node& _internal_tokentype(int index) const;
  ::pg_query::Node* _internal_add_tokentype();
  public:
  const ::pg_query::Node& tokentype(int index) const;
  ::pg_query::Node* add_tokentype();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      tokentype() const;

  // repeated .pg_query.Node dicts = 4 [json_name = "dicts"];
  int dicts_size() const;
  private:
  int _internal_dicts_size() const;
  public:
  void clear_dicts();
  ::pg_query::Node* mutable_dicts(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_dicts();
  private:
  const ::pg_query::Node& _internal_dicts(int index) const;
  ::pg_query::Node* _internal_add_dicts();
  public:
  const ::pg_query::Node& dicts(int index) const;
  ::pg_query::Node* add_dicts();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      dicts() const;

  // .pg_query.AlterTSConfigType kind = 1 [json_name = "kind"];
  void clear_kind();
  ::pg_query::AlterTSConfigType kind() const;
  void set_kind(::pg_query::AlterTSConfigType value);
  private:
  ::pg_query::AlterTSConfigType _internal_kind() const;
  void _internal_set_kind(::pg_query::AlterTSConfigType value);
  public:

  // bool override = 5 [json_name = "override"];
  void clear_override();
  bool override() const;
  void set_override(bool value);
  private:
  bool _internal_override() const;
  void _internal_set_override(bool value);
  public:

  // bool replace = 6 [json_name = "replace"];
  void clear_replace();
  bool replace() const;
  void set_replace(bool value);
  private:
  bool _internal_replace() const;
  void _internal_set_replace(bool value);
  public:

  // bool missing_ok = 7 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterTSConfigurationStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > cfgname_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > tokentype_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > dicts_;
  int kind_;
  bool override_;
  bool replace_;
  bool missing_ok_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateFdwStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateFdwStmt) */ {
 public:
  inline CreateFdwStmt() : CreateFdwStmt(nullptr) {}
  virtual ~CreateFdwStmt();

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

  inline CreateFdwStmt& operator=(const CreateFdwStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateFdwStmt& operator=(CreateFdwStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateFdwStmt& default_instance();

  static inline const CreateFdwStmt* internal_default_instance() {
    return reinterpret_cast<const CreateFdwStmt*>(
               &_CreateFdwStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    145;

  friend void swap(CreateFdwStmt& a, CreateFdwStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateFdwStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateFdwStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateFdwStmt* New() const final {
    return CreateMaybeMessage<CreateFdwStmt>(nullptr);
  }

  CreateFdwStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateFdwStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateFdwStmt& from);
  void MergeFrom(const CreateFdwStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateFdwStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateFdwStmt";
  }
  protected:
  explicit CreateFdwStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kFuncOptionsFieldNumber = 2,
    kOptionsFieldNumber = 3,
    kFdwnameFieldNumber = 1,
  };
  // repeated .pg_query.Node func_options = 2 [json_name = "func_options"];
  int func_options_size() const;
  private:
  int _internal_func_options_size() const;
  public:
  void clear_func_options();
  ::pg_query::Node* mutable_func_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_func_options();
  private:
  const ::pg_query::Node& _internal_func_options(int index) const;
  ::pg_query::Node* _internal_add_func_options();
  public:
  const ::pg_query::Node& func_options(int index) const;
  ::pg_query::Node* add_func_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      func_options() const;

  // repeated .pg_query.Node options = 3 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string fdwname = 1 [json_name = "fdwname"];
  void clear_fdwname();
  const std::string& fdwname() const;
  void set_fdwname(const std::string& value);
  void set_fdwname(std::string&& value);
  void set_fdwname(const char* value);
  void set_fdwname(const char* value, size_t size);
  std::string* mutable_fdwname();
  std::string* release_fdwname();
  void set_allocated_fdwname(std::string* fdwname);
  private:
  const std::string& _internal_fdwname() const;
  void _internal_set_fdwname(const std::string& value);
  std::string* _internal_mutable_fdwname();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateFdwStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > func_options_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fdwname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterFdwStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterFdwStmt) */ {
 public:
  inline AlterFdwStmt() : AlterFdwStmt(nullptr) {}
  virtual ~AlterFdwStmt();

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

  inline AlterFdwStmt& operator=(const AlterFdwStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterFdwStmt& operator=(AlterFdwStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterFdwStmt& default_instance();

  static inline const AlterFdwStmt* internal_default_instance() {
    return reinterpret_cast<const AlterFdwStmt*>(
               &_AlterFdwStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    146;

  friend void swap(AlterFdwStmt& a, AlterFdwStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterFdwStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterFdwStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterFdwStmt* New() const final {
    return CreateMaybeMessage<AlterFdwStmt>(nullptr);
  }

  AlterFdwStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterFdwStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterFdwStmt& from);
  void MergeFrom(const AlterFdwStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterFdwStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterFdwStmt";
  }
  protected:
  explicit AlterFdwStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kFuncOptionsFieldNumber = 2,
    kOptionsFieldNumber = 3,
    kFdwnameFieldNumber = 1,
  };
  // repeated .pg_query.Node func_options = 2 [json_name = "func_options"];
  int func_options_size() const;
  private:
  int _internal_func_options_size() const;
  public:
  void clear_func_options();
  ::pg_query::Node* mutable_func_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_func_options();
  private:
  const ::pg_query::Node& _internal_func_options(int index) const;
  ::pg_query::Node* _internal_add_func_options();
  public:
  const ::pg_query::Node& func_options(int index) const;
  ::pg_query::Node* add_func_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      func_options() const;

  // repeated .pg_query.Node options = 3 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string fdwname = 1 [json_name = "fdwname"];
  void clear_fdwname();
  const std::string& fdwname() const;
  void set_fdwname(const std::string& value);
  void set_fdwname(std::string&& value);
  void set_fdwname(const char* value);
  void set_fdwname(const char* value, size_t size);
  std::string* mutable_fdwname();
  std::string* release_fdwname();
  void set_allocated_fdwname(std::string* fdwname);
  private:
  const std::string& _internal_fdwname() const;
  void _internal_set_fdwname(const std::string& value);
  std::string* _internal_mutable_fdwname();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterFdwStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > func_options_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fdwname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateForeignServerStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateForeignServerStmt) */ {
 public:
  inline CreateForeignServerStmt() : CreateForeignServerStmt(nullptr) {}
  virtual ~CreateForeignServerStmt();

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

  inline CreateForeignServerStmt& operator=(const CreateForeignServerStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateForeignServerStmt& operator=(CreateForeignServerStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateForeignServerStmt& default_instance();

  static inline const CreateForeignServerStmt* internal_default_instance() {
    return reinterpret_cast<const CreateForeignServerStmt*>(
               &_CreateForeignServerStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    147;

  friend void swap(CreateForeignServerStmt& a, CreateForeignServerStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateForeignServerStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateForeignServerStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateForeignServerStmt* New() const final {
    return CreateMaybeMessage<CreateForeignServerStmt>(nullptr);
  }

  CreateForeignServerStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateForeignServerStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateForeignServerStmt& from);
  void MergeFrom(const CreateForeignServerStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateForeignServerStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateForeignServerStmt";
  }
  protected:
  explicit CreateForeignServerStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 6,
    kServernameFieldNumber = 1,
    kServertypeFieldNumber = 2,
    kVersionFieldNumber = 3,
    kFdwnameFieldNumber = 4,
    kIfNotExistsFieldNumber = 5,
  };
  // repeated .pg_query.Node options = 6 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string servername = 1 [json_name = "servername"];
  void clear_servername();
  const std::string& servername() const;
  void set_servername(const std::string& value);
  void set_servername(std::string&& value);
  void set_servername(const char* value);
  void set_servername(const char* value, size_t size);
  std::string* mutable_servername();
  std::string* release_servername();
  void set_allocated_servername(std::string* servername);
  private:
  const std::string& _internal_servername() const;
  void _internal_set_servername(const std::string& value);
  std::string* _internal_mutable_servername();
  public:

  // string servertype = 2 [json_name = "servertype"];
  void clear_servertype();
  const std::string& servertype() const;
  void set_servertype(const std::string& value);
  void set_servertype(std::string&& value);
  void set_servertype(const char* value);
  void set_servertype(const char* value, size_t size);
  std::string* mutable_servertype();
  std::string* release_servertype();
  void set_allocated_servertype(std::string* servertype);
  private:
  const std::string& _internal_servertype() const;
  void _internal_set_servertype(const std::string& value);
  std::string* _internal_mutable_servertype();
  public:

  // string version = 3 [json_name = "version"];
  void clear_version();
  const std::string& version() const;
  void set_version(const std::string& value);
  void set_version(std::string&& value);
  void set_version(const char* value);
  void set_version(const char* value, size_t size);
  std::string* mutable_version();
  std::string* release_version();
  void set_allocated_version(std::string* version);
  private:
  const std::string& _internal_version() const;
  void _internal_set_version(const std::string& value);
  std::string* _internal_mutable_version();
  public:

  // string fdwname = 4 [json_name = "fdwname"];
  void clear_fdwname();
  const std::string& fdwname() const;
  void set_fdwname(const std::string& value);
  void set_fdwname(std::string&& value);
  void set_fdwname(const char* value);
  void set_fdwname(const char* value, size_t size);
  std::string* mutable_fdwname();
  std::string* release_fdwname();
  void set_allocated_fdwname(std::string* fdwname);
  private:
  const std::string& _internal_fdwname() const;
  void _internal_set_fdwname(const std::string& value);
  std::string* _internal_mutable_fdwname();
  public:

  // bool if_not_exists = 5 [json_name = "if_not_exists"];
  void clear_if_not_exists();
  bool if_not_exists() const;
  void set_if_not_exists(bool value);
  private:
  bool _internal_if_not_exists() const;
  void _internal_set_if_not_exists(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateForeignServerStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servername_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servertype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fdwname_;
  bool if_not_exists_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterForeignServerStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterForeignServerStmt) */ {
 public:
  inline AlterForeignServerStmt() : AlterForeignServerStmt(nullptr) {}
  virtual ~AlterForeignServerStmt();

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

  inline AlterForeignServerStmt& operator=(const AlterForeignServerStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterForeignServerStmt& operator=(AlterForeignServerStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterForeignServerStmt& default_instance();

  static inline const AlterForeignServerStmt* internal_default_instance() {
    return reinterpret_cast<const AlterForeignServerStmt*>(
               &_AlterForeignServerStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    148;

  friend void swap(AlterForeignServerStmt& a, AlterForeignServerStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterForeignServerStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterForeignServerStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterForeignServerStmt* New() const final {
    return CreateMaybeMessage<AlterForeignServerStmt>(nullptr);
  }

  AlterForeignServerStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterForeignServerStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterForeignServerStmt& from);
  void MergeFrom(const AlterForeignServerStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterForeignServerStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterForeignServerStmt";
  }
  protected:
  explicit AlterForeignServerStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 3,
    kServernameFieldNumber = 1,
    kVersionFieldNumber = 2,
    kHasVersionFieldNumber = 4,
  };
  // repeated .pg_query.Node options = 3 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string servername = 1 [json_name = "servername"];
  void clear_servername();
  const std::string& servername() const;
  void set_servername(const std::string& value);
  void set_servername(std::string&& value);
  void set_servername(const char* value);
  void set_servername(const char* value, size_t size);
  std::string* mutable_servername();
  std::string* release_servername();
  void set_allocated_servername(std::string* servername);
  private:
  const std::string& _internal_servername() const;
  void _internal_set_servername(const std::string& value);
  std::string* _internal_mutable_servername();
  public:

  // string version = 2 [json_name = "version"];
  void clear_version();
  const std::string& version() const;
  void set_version(const std::string& value);
  void set_version(std::string&& value);
  void set_version(const char* value);
  void set_version(const char* value, size_t size);
  std::string* mutable_version();
  std::string* release_version();
  void set_allocated_version(std::string* version);
  private:
  const std::string& _internal_version() const;
  void _internal_set_version(const std::string& value);
  std::string* _internal_mutable_version();
  public:

  // bool has_version = 4 [json_name = "has_version"];
  void clear_has_version();
  bool has_version() const;
  void set_has_version(bool value);
  private:
  bool _internal_has_version() const;
  void _internal_set_has_version(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterForeignServerStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servername_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
  bool has_version_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateUserMappingStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateUserMappingStmt) */ {
 public:
  inline CreateUserMappingStmt() : CreateUserMappingStmt(nullptr) {}
  virtual ~CreateUserMappingStmt();

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

  inline CreateUserMappingStmt& operator=(const CreateUserMappingStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateUserMappingStmt& operator=(CreateUserMappingStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateUserMappingStmt& default_instance();

  static inline const CreateUserMappingStmt* internal_default_instance() {
    return reinterpret_cast<const CreateUserMappingStmt*>(
               &_CreateUserMappingStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    149;

  friend void swap(CreateUserMappingStmt& a, CreateUserMappingStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateUserMappingStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateUserMappingStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateUserMappingStmt* New() const final {
    return CreateMaybeMessage<CreateUserMappingStmt>(nullptr);
  }

  CreateUserMappingStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateUserMappingStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateUserMappingStmt& from);
  void MergeFrom(const CreateUserMappingStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateUserMappingStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateUserMappingStmt";
  }
  protected:
  explicit CreateUserMappingStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 4,
    kServernameFieldNumber = 2,
    kUserFieldNumber = 1,
    kIfNotExistsFieldNumber = 3,
  };
  // repeated .pg_query.Node options = 4 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string servername = 2 [json_name = "servername"];
  void clear_servername();
  const std::string& servername() const;
  void set_servername(const std::string& value);
  void set_servername(std::string&& value);
  void set_servername(const char* value);
  void set_servername(const char* value, size_t size);
  std::string* mutable_servername();
  std::string* release_servername();
  void set_allocated_servername(std::string* servername);
  private:
  const std::string& _internal_servername() const;
  void _internal_set_servername(const std::string& value);
  std::string* _internal_mutable_servername();
  public:

  // .pg_query.RoleSpec user = 1 [json_name = "user"];
  bool has_user() const;
  private:
  bool _internal_has_user() const;
  public:
  void clear_user();
  const ::pg_query::RoleSpec& user() const;
  ::pg_query::RoleSpec* release_user();
  ::pg_query::RoleSpec* mutable_user();
  void set_allocated_user(::pg_query::RoleSpec* user);
  private:
  const ::pg_query::RoleSpec& _internal_user() const;
  ::pg_query::RoleSpec* _internal_mutable_user();
  public:
  void unsafe_arena_set_allocated_user(
      ::pg_query::RoleSpec* user);
  ::pg_query::RoleSpec* unsafe_arena_release_user();

  // bool if_not_exists = 3 [json_name = "if_not_exists"];
  void clear_if_not_exists();
  bool if_not_exists() const;
  void set_if_not_exists(bool value);
  private:
  bool _internal_if_not_exists() const;
  void _internal_set_if_not_exists(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateUserMappingStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servername_;
  ::pg_query::RoleSpec* user_;
  bool if_not_exists_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterUserMappingStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterUserMappingStmt) */ {
 public:
  inline AlterUserMappingStmt() : AlterUserMappingStmt(nullptr) {}
  virtual ~AlterUserMappingStmt();

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

  inline AlterUserMappingStmt& operator=(const AlterUserMappingStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterUserMappingStmt& operator=(AlterUserMappingStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterUserMappingStmt& default_instance();

  static inline const AlterUserMappingStmt* internal_default_instance() {
    return reinterpret_cast<const AlterUserMappingStmt*>(
               &_AlterUserMappingStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    150;

  friend void swap(AlterUserMappingStmt& a, AlterUserMappingStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterUserMappingStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterUserMappingStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterUserMappingStmt* New() const final {
    return CreateMaybeMessage<AlterUserMappingStmt>(nullptr);
  }

  AlterUserMappingStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterUserMappingStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterUserMappingStmt& from);
  void MergeFrom(const AlterUserMappingStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterUserMappingStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterUserMappingStmt";
  }
  protected:
  explicit AlterUserMappingStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 3,
    kServernameFieldNumber = 2,
    kUserFieldNumber = 1,
  };
  // repeated .pg_query.Node options = 3 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string servername = 2 [json_name = "servername"];
  void clear_servername();
  const std::string& servername() const;
  void set_servername(const std::string& value);
  void set_servername(std::string&& value);
  void set_servername(const char* value);
  void set_servername(const char* value, size_t size);
  std::string* mutable_servername();
  std::string* release_servername();
  void set_allocated_servername(std::string* servername);
  private:
  const std::string& _internal_servername() const;
  void _internal_set_servername(const std::string& value);
  std::string* _internal_mutable_servername();
  public:

  // .pg_query.RoleSpec user = 1 [json_name = "user"];
  bool has_user() const;
  private:
  bool _internal_has_user() const;
  public:
  void clear_user();
  const ::pg_query::RoleSpec& user() const;
  ::pg_query::RoleSpec* release_user();
  ::pg_query::RoleSpec* mutable_user();
  void set_allocated_user(::pg_query::RoleSpec* user);
  private:
  const ::pg_query::RoleSpec& _internal_user() const;
  ::pg_query::RoleSpec* _internal_mutable_user();
  public:
  void unsafe_arena_set_allocated_user(
      ::pg_query::RoleSpec* user);
  ::pg_query::RoleSpec* unsafe_arena_release_user();

  // @@protoc_insertion_point(class_scope:pg_query.AlterUserMappingStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servername_;
  ::pg_query::RoleSpec* user_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class DropUserMappingStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropUserMappingStmt) */ {
 public:
  inline DropUserMappingStmt() : DropUserMappingStmt(nullptr) {}
  virtual ~DropUserMappingStmt();

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

  inline DropUserMappingStmt& operator=(const DropUserMappingStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline DropUserMappingStmt& operator=(DropUserMappingStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DropUserMappingStmt& default_instance();

  static inline const DropUserMappingStmt* internal_default_instance() {
    return reinterpret_cast<const DropUserMappingStmt*>(
               &_DropUserMappingStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    151;

  friend void swap(DropUserMappingStmt& a, DropUserMappingStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(DropUserMappingStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DropUserMappingStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline DropUserMappingStmt* New() const final {
    return CreateMaybeMessage<DropUserMappingStmt>(nullptr);
  }

  DropUserMappingStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DropUserMappingStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DropUserMappingStmt& from);
  void MergeFrom(const DropUserMappingStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DropUserMappingStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DropUserMappingStmt";
  }
  protected:
  explicit DropUserMappingStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kServernameFieldNumber = 2,
    kUserFieldNumber = 1,
    kMissingOkFieldNumber = 3,
  };
  // string servername = 2 [json_name = "servername"];
  void clear_servername();
  const std::string& servername() const;
  void set_servername(const std::string& value);
  void set_servername(std::string&& value);
  void set_servername(const char* value);
  void set_servername(const char* value, size_t size);
  std::string* mutable_servername();
  std::string* release_servername();
  void set_allocated_servername(std::string* servername);
  private:
  const std::string& _internal_servername() const;
  void _internal_set_servername(const std::string& value);
  std::string* _internal_mutable_servername();
  public:

  // .pg_query.RoleSpec user = 1 [json_name = "user"];
  bool has_user() const;
  private:
  bool _internal_has_user() const;
  public:
  void clear_user();
  const ::pg_query::RoleSpec& user() const;
  ::pg_query::RoleSpec* release_user();
  ::pg_query::RoleSpec* mutable_user();
  void set_allocated_user(::pg_query::RoleSpec* user);
  private:
  const ::pg_query::RoleSpec& _internal_user() const;
  ::pg_query::RoleSpec* _internal_mutable_user();
  public:
  void unsafe_arena_set_allocated_user(
      ::pg_query::RoleSpec* user);
  ::pg_query::RoleSpec* unsafe_arena_release_user();

  // bool missing_ok = 3 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.DropUserMappingStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servername_;
  ::pg_query::RoleSpec* user_;
  bool missing_ok_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterTableSpaceOptionsStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTableSpaceOptionsStmt) */ {
 public:
  inline AlterTableSpaceOptionsStmt() : AlterTableSpaceOptionsStmt(nullptr) {}
  virtual ~AlterTableSpaceOptionsStmt();

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

  inline AlterTableSpaceOptionsStmt& operator=(const AlterTableSpaceOptionsStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterTableSpaceOptionsStmt& operator=(AlterTableSpaceOptionsStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterTableSpaceOptionsStmt& default_instance();

  static inline const AlterTableSpaceOptionsStmt* internal_default_instance() {
    return reinterpret_cast<const AlterTableSpaceOptionsStmt*>(
               &_AlterTableSpaceOptionsStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    152;

  friend void swap(AlterTableSpaceOptionsStmt& a, AlterTableSpaceOptionsStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterTableSpaceOptionsStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterTableSpaceOptionsStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterTableSpaceOptionsStmt* New() const final {
    return CreateMaybeMessage<AlterTableSpaceOptionsStmt>(nullptr);
  }

  AlterTableSpaceOptionsStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterTableSpaceOptionsStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterTableSpaceOptionsStmt& from);
  void MergeFrom(const AlterTableSpaceOptionsStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterTableSpaceOptionsStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterTableSpaceOptionsStmt";
  }
  protected:
  explicit AlterTableSpaceOptionsStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 2,
    kTablespacenameFieldNumber = 1,
    kIsResetFieldNumber = 3,
  };
  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string tablespacename = 1 [json_name = "tablespacename"];
  void clear_tablespacename();
  const std::string& tablespacename() const;
  void set_tablespacename(const std::string& value);
  void set_tablespacename(std::string&& value);
  void set_tablespacename(const char* value);
  void set_tablespacename(const char* value, size_t size);
  std::string* mutable_tablespacename();
  std::string* release_tablespacename();
  void set_allocated_tablespacename(std::string* tablespacename);
  private:
  const std::string& _internal_tablespacename() const;
  void _internal_set_tablespacename(const std::string& value);
  std::string* _internal_mutable_tablespacename();
  public:

  // bool is_reset = 3 [json_name = "isReset"];
  void clear_is_reset();
  bool is_reset() const;
  void set_is_reset(bool value);
  private:
  bool _internal_is_reset() const;
  void _internal_set_is_reset(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterTableSpaceOptionsStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tablespacename_;
  bool is_reset_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterTableMoveAllStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTableMoveAllStmt) */ {
 public:
  inline AlterTableMoveAllStmt() : AlterTableMoveAllStmt(nullptr) {}
  virtual ~AlterTableMoveAllStmt();

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

  inline AlterTableMoveAllStmt& operator=(const AlterTableMoveAllStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterTableMoveAllStmt& operator=(AlterTableMoveAllStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterTableMoveAllStmt& default_instance();

  static inline const AlterTableMoveAllStmt* internal_default_instance() {
    return reinterpret_cast<const AlterTableMoveAllStmt*>(
               &_AlterTableMoveAllStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    153;

  friend void swap(AlterTableMoveAllStmt& a, AlterTableMoveAllStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterTableMoveAllStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterTableMoveAllStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterTableMoveAllStmt* New() const final {
    return CreateMaybeMessage<AlterTableMoveAllStmt>(nullptr);
  }

  AlterTableMoveAllStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterTableMoveAllStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterTableMoveAllStmt& from);
  void MergeFrom(const AlterTableMoveAllStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterTableMoveAllStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterTableMoveAllStmt";
  }
  protected:
  explicit AlterTableMoveAllStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRolesFieldNumber = 3,
    kOrigTablespacenameFieldNumber = 1,
    kNewTablespacenameFieldNumber = 4,
    kObjtypeFieldNumber = 2,
    kNowaitFieldNumber = 5,
  };
  // repeated .pg_query.Node roles = 3 [json_name = "roles"];
  int roles_size() const;
  private:
  int _internal_roles_size() const;
  public:
  void clear_roles();
  ::pg_query::Node* mutable_roles(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_roles();
  private:
  const ::pg_query::Node& _internal_roles(int index) const;
  ::pg_query::Node* _internal_add_roles();
  public:
  const ::pg_query::Node& roles(int index) const;
  ::pg_query::Node* add_roles();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      roles() const;

  // string orig_tablespacename = 1 [json_name = "orig_tablespacename"];
  void clear_orig_tablespacename();
  const std::string& orig_tablespacename() const;
  void set_orig_tablespacename(const std::string& value);
  void set_orig_tablespacename(std::string&& value);
  void set_orig_tablespacename(const char* value);
  void set_orig_tablespacename(const char* value, size_t size);
  std::string* mutable_orig_tablespacename();
  std::string* release_orig_tablespacename();
  void set_allocated_orig_tablespacename(std::string* orig_tablespacename);
  private:
  const std::string& _internal_orig_tablespacename() const;
  void _internal_set_orig_tablespacename(const std::string& value);
  std::string* _internal_mutable_orig_tablespacename();
  public:

  // string new_tablespacename = 4 [json_name = "new_tablespacename"];
  void clear_new_tablespacename();
  const std::string& new_tablespacename() const;
  void set_new_tablespacename(const std::string& value);
  void set_new_tablespacename(std::string&& value);
  void set_new_tablespacename(const char* value);
  void set_new_tablespacename(const char* value, size_t size);
  std::string* mutable_new_tablespacename();
  std::string* release_new_tablespacename();
  void set_allocated_new_tablespacename(std::string* new_tablespacename);
  private:
  const std::string& _internal_new_tablespacename() const;
  void _internal_set_new_tablespacename(const std::string& value);
  std::string* _internal_mutable_new_tablespacename();
  public:

  // .pg_query.ObjectType objtype = 2 [json_name = "objtype"];
  void clear_objtype();
  ::pg_query::ObjectType objtype() const;
  void set_objtype(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_objtype() const;
  void _internal_set_objtype(::pg_query::ObjectType value);
  public:

  // bool nowait = 5 [json_name = "nowait"];
  void clear_nowait();
  bool nowait() const;
  void set_nowait(bool value);
  private:
  bool _internal_nowait() const;
  void _internal_set_nowait(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterTableMoveAllStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > roles_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr orig_tablespacename_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr new_tablespacename_;
  int objtype_;
  bool nowait_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class SecLabelStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SecLabelStmt) */ {
 public:
  inline SecLabelStmt() : SecLabelStmt(nullptr) {}
  virtual ~SecLabelStmt();

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

  inline SecLabelStmt& operator=(const SecLabelStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline SecLabelStmt& operator=(SecLabelStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SecLabelStmt& default_instance();

  static inline const SecLabelStmt* internal_default_instance() {
    return reinterpret_cast<const SecLabelStmt*>(
               &_SecLabelStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    154;

  friend void swap(SecLabelStmt& a, SecLabelStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(SecLabelStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SecLabelStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SecLabelStmt* New() const final {
    return CreateMaybeMessage<SecLabelStmt>(nullptr);
  }

  SecLabelStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SecLabelStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SecLabelStmt& from);
  void MergeFrom(const SecLabelStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SecLabelStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.SecLabelStmt";
  }
  protected:
  explicit SecLabelStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kProviderFieldNumber = 3,
    kLabelFieldNumber = 4,
    kObjectFieldNumber = 2,
    kObjtypeFieldNumber = 1,
  };
  // string provider = 3 [json_name = "provider"];
  void clear_provider();
  const std::string& provider() const;
  void set_provider(const std::string& value);
  void set_provider(std::string&& value);
  void set_provider(const char* value);
  void set_provider(const char* value, size_t size);
  std::string* mutable_provider();
  std::string* release_provider();
  void set_allocated_provider(std::string* provider);
  private:
  const std::string& _internal_provider() const;
  void _internal_set_provider(const std::string& value);
  std::string* _internal_mutable_provider();
  public:

  // string label = 4 [json_name = "label"];
  void clear_label();
  const std::string& label() const;
  void set_label(const std::string& value);
  void set_label(std::string&& value);
  void set_label(const char* value);
  void set_label(const char* value, size_t size);
  std::string* mutable_label();
  std::string* release_label();
  void set_allocated_label(std::string* label);
  private:
  const std::string& _internal_label() const;
  void _internal_set_label(const std::string& value);
  std::string* _internal_mutable_label();
  public:

  // .pg_query.Node object = 2 [json_name = "object"];
  bool has_object() const;
  private:
  bool _internal_has_object() const;
  public:
  void clear_object();
  const ::pg_query::Node& object() const;
  ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* object);
  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();
  public:
  void unsafe_arena_set_allocated_object(
      ::pg_query::Node* object);
  ::pg_query::Node* unsafe_arena_release_object();

  // .pg_query.ObjectType objtype = 1 [json_name = "objtype"];
  void clear_objtype();
  ::pg_query::ObjectType objtype() const;
  void set_objtype(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_objtype() const;
  void _internal_set_objtype(::pg_query::ObjectType value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.SecLabelStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr label_;
  ::pg_query::Node* object_;
  int objtype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateForeignTableStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateForeignTableStmt) */ {
 public:
  inline CreateForeignTableStmt() : CreateForeignTableStmt(nullptr) {}
  virtual ~CreateForeignTableStmt();

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

  inline CreateForeignTableStmt& operator=(const CreateForeignTableStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateForeignTableStmt& operator=(CreateForeignTableStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateForeignTableStmt& default_instance();

  static inline const CreateForeignTableStmt* internal_default_instance() {
    return reinterpret_cast<const CreateForeignTableStmt*>(
               &_CreateForeignTableStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    155;

  friend void swap(CreateForeignTableStmt& a, CreateForeignTableStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateForeignTableStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateForeignTableStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateForeignTableStmt* New() const final {
    return CreateMaybeMessage<CreateForeignTableStmt>(nullptr);
  }

  CreateForeignTableStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateForeignTableStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateForeignTableStmt& from);
  void MergeFrom(const CreateForeignTableStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateForeignTableStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateForeignTableStmt";
  }
  protected:
  explicit CreateForeignTableStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 3,
    kServernameFieldNumber = 2,
    kBaseStmtFieldNumber = 1,
  };
  // repeated .pg_query.Node options = 3 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string servername = 2 [json_name = "servername"];
  void clear_servername();
  const std::string& servername() const;
  void set_servername(const std::string& value);
  void set_servername(std::string&& value);
  void set_servername(const char* value);
  void set_servername(const char* value, size_t size);
  std::string* mutable_servername();
  std::string* release_servername();
  void set_allocated_servername(std::string* servername);
  private:
  const std::string& _internal_servername() const;
  void _internal_set_servername(const std::string& value);
  std::string* _internal_mutable_servername();
  public:

  // .pg_query.CreateStmt base_stmt = 1 [json_name = "base"];
  bool has_base_stmt() const;
  private:
  bool _internal_has_base_stmt() const;
  public:
  void clear_base_stmt();
  const ::pg_query::CreateStmt& base_stmt() const;
  ::pg_query::CreateStmt* release_base_stmt();
  ::pg_query::CreateStmt* mutable_base_stmt();
  void set_allocated_base_stmt(::pg_query::CreateStmt* base_stmt);
  private:
  const ::pg_query::CreateStmt& _internal_base_stmt() const;
  ::pg_query::CreateStmt* _internal_mutable_base_stmt();
  public:
  void unsafe_arena_set_allocated_base_stmt(
      ::pg_query::CreateStmt* base_stmt);
  ::pg_query::CreateStmt* unsafe_arena_release_base_stmt();

  // @@protoc_insertion_point(class_scope:pg_query.CreateForeignTableStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servername_;
  ::pg_query::CreateStmt* base_stmt_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ImportForeignSchemaStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ImportForeignSchemaStmt) */ {
 public:
  inline ImportForeignSchemaStmt() : ImportForeignSchemaStmt(nullptr) {}
  virtual ~ImportForeignSchemaStmt();

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

  inline ImportForeignSchemaStmt& operator=(const ImportForeignSchemaStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline ImportForeignSchemaStmt& operator=(ImportForeignSchemaStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ImportForeignSchemaStmt& default_instance();

  static inline const ImportForeignSchemaStmt* internal_default_instance() {
    return reinterpret_cast<const ImportForeignSchemaStmt*>(
               &_ImportForeignSchemaStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    156;

  friend void swap(ImportForeignSchemaStmt& a, ImportForeignSchemaStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ImportForeignSchemaStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ImportForeignSchemaStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ImportForeignSchemaStmt* New() const final {
    return CreateMaybeMessage<ImportForeignSchemaStmt>(nullptr);
  }

  ImportForeignSchemaStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ImportForeignSchemaStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ImportForeignSchemaStmt& from);
  void MergeFrom(const ImportForeignSchemaStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ImportForeignSchemaStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ImportForeignSchemaStmt";
  }
  protected:
  explicit ImportForeignSchemaStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTableListFieldNumber = 5,
    kOptionsFieldNumber = 6,
    kServerNameFieldNumber = 1,
    kRemoteSchemaFieldNumber = 2,
    kLocalSchemaFieldNumber = 3,
    kListTypeFieldNumber = 4,
  };
  // repeated .pg_query.Node table_list = 5 [json_name = "table_list"];
  int table_list_size() const;
  private:
  int _internal_table_list_size() const;
  public:
  void clear_table_list();
  ::pg_query::Node* mutable_table_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_table_list();
  private:
  const ::pg_query::Node& _internal_table_list(int index) const;
  ::pg_query::Node* _internal_add_table_list();
  public:
  const ::pg_query::Node& table_list(int index) const;
  ::pg_query::Node* add_table_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      table_list() const;

  // repeated .pg_query.Node options = 6 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string server_name = 1 [json_name = "server_name"];
  void clear_server_name();
  const std::string& server_name() const;
  void set_server_name(const std::string& value);
  void set_server_name(std::string&& value);
  void set_server_name(const char* value);
  void set_server_name(const char* value, size_t size);
  std::string* mutable_server_name();
  std::string* release_server_name();
  void set_allocated_server_name(std::string* server_name);
  private:
  const std::string& _internal_server_name() const;
  void _internal_set_server_name(const std::string& value);
  std::string* _internal_mutable_server_name();
  public:

  // string remote_schema = 2 [json_name = "remote_schema"];
  void clear_remote_schema();
  const std::string& remote_schema() const;
  void set_remote_schema(const std::string& value);
  void set_remote_schema(std::string&& value);
  void set_remote_schema(const char* value);
  void set_remote_schema(const char* value, size_t size);
  std::string* mutable_remote_schema();
  std::string* release_remote_schema();
  void set_allocated_remote_schema(std::string* remote_schema);
  private:
  const std::string& _internal_remote_schema() const;
  void _internal_set_remote_schema(const std::string& value);
  std::string* _internal_mutable_remote_schema();
  public:

  // string local_schema = 3 [json_name = "local_schema"];
  void clear_local_schema();
  const std::string& local_schema() const;
  void set_local_schema(const std::string& value);
  void set_local_schema(std::string&& value);
  void set_local_schema(const char* value);
  void set_local_schema(const char* value, size_t size);
  std::string* mutable_local_schema();
  std::string* release_local_schema();
  void set_allocated_local_schema(std::string* local_schema);
  private:
  const std::string& _internal_local_schema() const;
  void _internal_set_local_schema(const std::string& value);
  std::string* _internal_mutable_local_schema();
  public:

  // .pg_query.ImportForeignSchemaType list_type = 4 [json_name = "list_type"];
  void clear_list_type();
  ::pg_query::ImportForeignSchemaType list_type() const;
  void set_list_type(::pg_query::ImportForeignSchemaType value);
  private:
  ::pg_query::ImportForeignSchemaType _internal_list_type() const;
  void _internal_set_list_type(::pg_query::ImportForeignSchemaType value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ImportForeignSchemaStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > table_list_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr server_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remote_schema_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr local_schema_;
  int list_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateExtensionStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateExtensionStmt) */ {
 public:
  inline CreateExtensionStmt() : CreateExtensionStmt(nullptr) {}
  virtual ~CreateExtensionStmt();

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

  inline CreateExtensionStmt& operator=(const CreateExtensionStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateExtensionStmt& operator=(CreateExtensionStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateExtensionStmt& default_instance();

  static inline const CreateExtensionStmt* internal_default_instance() {
    return reinterpret_cast<const CreateExtensionStmt*>(
               &_CreateExtensionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    157;

  friend void swap(CreateExtensionStmt& a, CreateExtensionStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateExtensionStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateExtensionStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CreateExtensionStmt* New() const final {
    return CreateMaybeMessage<CreateExtensionStmt>(nullptr);
  }

  CreateExtensionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateExtensionStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateExtensionStmt& from);
  void MergeFrom(const CreateExtensionStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateExtensionStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateExtensionStmt";
  }
  protected:
  explicit CreateExtensionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kOptionsFieldNumber = 3,
    kExtnameFieldNumber = 1,
    kIfNotExistsFieldNumber = 2,
  };
  // repeated .pg_query.Node options = 3 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string extname = 1 [json_name = "extname"];
  void clear_extname();
  const std::string& extname() const;
  void set_extname(const std::string& value);
  void set_extname(std::string&& value);
  void set_extname(const char* value);
  void set_extname(const char* value, size_t size);
  std::string* mutable_extname();
  std::string* release_extname();
  void set_allocated_extname(std::string* extname);
  private:
  const std::string& _internal_extname() const;
  void _internal_set_extname(const std::string& value);
  std::string* _internal_mutable_extname();
  public:

  // bool if_not_exists = 2 [json_name = "if_not_exists"];
  void clear_if_not_exists();
  bool if_not_exists() const;
  void set_if_not_exists(bool value);
  private:
  bool _internal_if_not_exists() const;
  void _internal_set_if_not_exists(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateExtensionStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extname_;
  bool if_not_exists_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterExtensionStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterExtensionStmt) */ {
 public:
  inline AlterExtensionStmt() : AlterExtensionStmt(nullptr) {}
  virtual ~AlterExtensionStmt();

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

  inline AlterExtensionStmt& operator=(const AlterExtensionStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterExtensionStmt& operator=(AlterExtensionStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterExtensionStmt& default_instance();

  static inline const AlterExtensionStmt* internal_default_instance() {
    return reinterpret_cast<const AlterExtensionStmt*>(
               &_AlterExtensionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    158;

  friend void swap(AlterExtensionStmt& a, AlterExtensionStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterExtensionStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterExtensionStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AlterExtensionStmt* New() const final {
    return CreateMaybeMessage<AlterExtensionStmt>(nullptr);
  }

  AlterExtensionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterExtensionStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterExtensionStmt& from);
  void MergeFrom(const AlterExtensionStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterExtensionStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterExtensionStmt";
  }
  protected:
  explicit AlterExtensionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOptionsFieldNumber = 2,
    kExtnameFieldNumber = 1,
  };
  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string extname = 1 [json_name = "extname"];
  void clear_extname();
  const std::string& extname() const;
  void set_extname(const std::string& value);
  void set_extname(std::string&& value);
  void set_extname(const char* value);
  void set_extname(const char* value, size_t size);
  std::string* mutable_extname();
  std::string* release_extname();
  void set_allocated_extname(std::string* extname);
  private:
  const std::string& _internal_extname() const;
  void _internal_set_extname(const std::string& value);
  std::string* _internal_mutable_extname();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterExtensionStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterExtensionContentsStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterExtensionContentsStmt) */ {
 public:
  inline AlterExtensionContentsStmt() : AlterExtensionContentsStmt(nullptr) {}
  virtual ~AlterExtensionContentsStmt();

  AlterExtensionContentsStmt(const AlterExtensionContentsStmt& from);
  AlterExtensionContentsStmt(AlterExtensionContentsStmt&& from) noexcept
    : AlterExtensionContentsStmt() {
    *this = ::std::move(from);
  }

  inline AlterExtensionContentsStmt& operator=(const AlterExtensionContentsStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterExtensionContentsStmt& operator=(AlterExtensionContentsStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterExtensionContentsStmt& default_instance();

  static inline const AlterExtensionContentsStmt* internal_default_instance() {
    return reinterpret_cast<const AlterExtensionContentsStmt*>(
               &_AlterExtensionContentsStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    159;

  friend void swap(AlterExtensionContentsStmt& a, AlterExtensionContentsStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterExtensionContentsStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterExtensionContentsStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline AlterExtensionContentsStmt* New() const final {
    return CreateMaybeMessage<AlterExtensionContentsStmt>(nullptr);
  }

  AlterExtensionContentsStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterExtensionContentsStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterExtensionContentsStmt& from);
  void MergeFrom(const AlterExtensionContentsStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterExtensionContentsStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterExtensionContentsStmt";
  }
  protected:
  explicit AlterExtensionContentsStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kExtnameFieldNumber = 1,
    kObjectFieldNumber = 4,
    kActionFieldNumber = 2,
    kObjtypeFieldNumber = 3,
  };
  // string extname = 1 [json_name = "extname"];
  void clear_extname();
  const std::string& extname() const;
  void set_extname(const std::string& value);
  void set_extname(std::string&& value);
  void set_extname(const char* value);
  void set_extname(const char* value, size_t size);
  std::string* mutable_extname();
  std::string* release_extname();
  void set_allocated_extname(std::string* extname);
  private:
  const std::string& _internal_extname() const;
  void _internal_set_extname(const std::string& value);
  std::string* _internal_mutable_extname();
  public:

  // .pg_query.Node object = 4 [json_name = "object"];
  bool has_object() const;
  private:
  bool _internal_has_object() const;
  public:
  void clear_object();
  const ::pg_query::Node& object() const;
  ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* object);
  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();
  public:
  void unsafe_arena_set_allocated_object(
      ::pg_query::Node* object);
  ::pg_query::Node* unsafe_arena_release_object();

  // int32 action = 2 [json_name = "action"];
  void clear_action();
  ::PROTOBUF_NAMESPACE_ID::int32 action() const;
  void set_action(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_action() const;
  void _internal_set_action(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // .pg_query.ObjectType objtype = 3 [json_name = "objtype"];
  void clear_objtype();
  ::pg_query::ObjectType objtype() const;
  void set_objtype(::pg_query::ObjectType value);
  private:
  ::pg_query::ObjectType _internal_objtype() const;
  void _internal_set_objtype(::pg_query::ObjectType value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterExtensionContentsStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extname_;
  ::pg_query::Node* object_;
  ::PROTOBUF_NAMESPACE_ID::int32 action_;
  int objtype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateEventTrigStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateEventTrigStmt) */ {
 public:
  inline CreateEventTrigStmt() : CreateEventTrigStmt(nullptr) {}
  virtual ~CreateEventTrigStmt();

  CreateEventTrigStmt(const CreateEventTrigStmt& from);
  CreateEventTrigStmt(CreateEventTrigStmt&& from) noexcept
    : CreateEventTrigStmt() {
    *this = ::std::move(from);
  }

  inline CreateEventTrigStmt& operator=(const CreateEventTrigStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateEventTrigStmt& operator=(CreateEventTrigStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateEventTrigStmt& default_instance();

  static inline const CreateEventTrigStmt* internal_default_instance() {
    return reinterpret_cast<const CreateEventTrigStmt*>(
               &_CreateEventTrigStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    160;

  friend void swap(CreateEventTrigStmt& a, CreateEventTrigStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateEventTrigStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateEventTrigStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreateEventTrigStmt* New() const final {
    return CreateMaybeMessage<CreateEventTrigStmt>(nullptr);
  }

  CreateEventTrigStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateEventTrigStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateEventTrigStmt& from);
  void MergeFrom(const CreateEventTrigStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateEventTrigStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateEventTrigStmt";
  }
  protected:
  explicit CreateEventTrigStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kWhenclauseFieldNumber = 3,
    kFuncnameFieldNumber = 4,
    kTrignameFieldNumber = 1,
    kEventnameFieldNumber = 2,
  };
  // repeated .pg_query.Node whenclause = 3 [json_name = "whenclause"];
  int whenclause_size() const;
  private:
  int _internal_whenclause_size() const;
  public:
  void clear_whenclause();
  ::pg_query::Node* mutable_whenclause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_whenclause();
  private:
  const ::pg_query::Node& _internal_whenclause(int index) const;
  ::pg_query::Node* _internal_add_whenclause();
  public:
  const ::pg_query::Node& whenclause(int index) const;
  ::pg_query::Node* add_whenclause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      whenclause() const;

  // repeated .pg_query.Node funcname = 4 [json_name = "funcname"];
  int funcname_size() const;
  private:
  int _internal_funcname_size() const;
  public:
  void clear_funcname();
  ::pg_query::Node* mutable_funcname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_funcname();
  private:
  const ::pg_query::Node& _internal_funcname(int index) const;
  ::pg_query::Node* _internal_add_funcname();
  public:
  const ::pg_query::Node& funcname(int index) const;
  ::pg_query::Node* add_funcname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      funcname() const;

  // string trigname = 1 [json_name = "trigname"];
  void clear_trigname();
  const std::string& trigname() const;
  void set_trigname(const std::string& value);
  void set_trigname(std::string&& value);
  void set_trigname(const char* value);
  void set_trigname(const char* value, size_t size);
  std::string* mutable_trigname();
  std::string* release_trigname();
  void set_allocated_trigname(std::string* trigname);
  private:
  const std::string& _internal_trigname() const;
  void _internal_set_trigname(const std::string& value);
  std::string* _internal_mutable_trigname();
  public:

  // string eventname = 2 [json_name = "eventname"];
  void clear_eventname();
  const std::string& eventname() const;
  void set_eventname(const std::string& value);
  void set_eventname(std::string&& value);
  void set_eventname(const char* value);
  void set_eventname(const char* value, size_t size);
  std::string* mutable_eventname();
  std::string* release_eventname();
  void set_allocated_eventname(std::string* eventname);
  private:
  const std::string& _internal_eventname() const;
  void _internal_set_eventname(const std::string& value);
  std::string* _internal_mutable_eventname();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateEventTrigStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > whenclause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funcname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr trigname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eventname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterEventTrigStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterEventTrigStmt) */ {
 public:
  inline AlterEventTrigStmt() : AlterEventTrigStmt(nullptr) {}
  virtual ~AlterEventTrigStmt();

  AlterEventTrigStmt(const AlterEventTrigStmt& from);
  AlterEventTrigStmt(AlterEventTrigStmt&& from) noexcept
    : AlterEventTrigStmt() {
    *this = ::std::move(from);
  }

  inline AlterEventTrigStmt& operator=(const AlterEventTrigStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterEventTrigStmt& operator=(AlterEventTrigStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterEventTrigStmt& default_instance();

  static inline const AlterEventTrigStmt* internal_default_instance() {
    return reinterpret_cast<const AlterEventTrigStmt*>(
               &_AlterEventTrigStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    161;

  friend void swap(AlterEventTrigStmt& a, AlterEventTrigStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterEventTrigStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterEventTrigStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline AlterEventTrigStmt* New() const final {
    return CreateMaybeMessage<AlterEventTrigStmt>(nullptr);
  }

  AlterEventTrigStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterEventTrigStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterEventTrigStmt& from);
  void MergeFrom(const AlterEventTrigStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterEventTrigStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterEventTrigStmt";
  }
  protected:
  explicit AlterEventTrigStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTrignameFieldNumber = 1,
    kTgenabledFieldNumber = 2,
  };
  // string trigname = 1 [json_name = "trigname"];
  void clear_trigname();
  const std::string& trigname() const;
  void set_trigname(const std::string& value);
  void set_trigname(std::string&& value);
  void set_trigname(const char* value);
  void set_trigname(const char* value, size_t size);
  std::string* mutable_trigname();
  std::string* release_trigname();
  void set_allocated_trigname(std::string* trigname);
  private:
  const std::string& _internal_trigname() const;
  void _internal_set_trigname(const std::string& value);
  std::string* _internal_mutable_trigname();
  public:

  // string tgenabled = 2 [json_name = "tgenabled"];
  void clear_tgenabled();
  const std::string& tgenabled() const;
  void set_tgenabled(const std::string& value);
  void set_tgenabled(std::string&& value);
  void set_tgenabled(const char* value);
  void set_tgenabled(const char* value, size_t size);
  std::string* mutable_tgenabled();
  std::string* release_tgenabled();
  void set_allocated_tgenabled(std::string* tgenabled);
  private:
  const std::string& _internal_tgenabled() const;
  void _internal_set_tgenabled(const std::string& value);
  std::string* _internal_mutable_tgenabled();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterEventTrigStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr trigname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tgenabled_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RefreshMatViewStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RefreshMatViewStmt) */ {
 public:
  inline RefreshMatViewStmt() : RefreshMatViewStmt(nullptr) {}
  virtual ~RefreshMatViewStmt();

  RefreshMatViewStmt(const RefreshMatViewStmt& from);
  RefreshMatViewStmt(RefreshMatViewStmt&& from) noexcept
    : RefreshMatViewStmt() {
    *this = ::std::move(from);
  }

  inline RefreshMatViewStmt& operator=(const RefreshMatViewStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline RefreshMatViewStmt& operator=(RefreshMatViewStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RefreshMatViewStmt& default_instance();

  static inline const RefreshMatViewStmt* internal_default_instance() {
    return reinterpret_cast<const RefreshMatViewStmt*>(
               &_RefreshMatViewStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    162;

  friend void swap(RefreshMatViewStmt& a, RefreshMatViewStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(RefreshMatViewStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RefreshMatViewStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RefreshMatViewStmt* New() const final {
    return CreateMaybeMessage<RefreshMatViewStmt>(nullptr);
  }

  RefreshMatViewStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RefreshMatViewStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RefreshMatViewStmt& from);
  void MergeFrom(const RefreshMatViewStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RefreshMatViewStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RefreshMatViewStmt";
  }
  protected:
  explicit RefreshMatViewStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRelationFieldNumber = 3,
    kConcurrentFieldNumber = 1,
    kSkipDataFieldNumber = 2,
  };
  // .pg_query.RangeVar relation = 3 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // bool concurrent = 1 [json_name = "concurrent"];
  void clear_concurrent();
  bool concurrent() const;
  void set_concurrent(bool value);
  private:
  bool _internal_concurrent() const;
  void _internal_set_concurrent(bool value);
  public:

  // bool skip_data = 2 [json_name = "skipData"];
  void clear_skip_data();
  bool skip_data() const;
  void set_skip_data(bool value);
  private:
  bool _internal_skip_data() const;
  void _internal_set_skip_data(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RefreshMatViewStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::RangeVar* relation_;
  bool concurrent_;
  bool skip_data_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ReplicaIdentityStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ReplicaIdentityStmt) */ {
 public:
  inline ReplicaIdentityStmt() : ReplicaIdentityStmt(nullptr) {}
  virtual ~ReplicaIdentityStmt();

  ReplicaIdentityStmt(const ReplicaIdentityStmt& from);
  ReplicaIdentityStmt(ReplicaIdentityStmt&& from) noexcept
    : ReplicaIdentityStmt() {
    *this = ::std::move(from);
  }

  inline ReplicaIdentityStmt& operator=(const ReplicaIdentityStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReplicaIdentityStmt& operator=(ReplicaIdentityStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ReplicaIdentityStmt& default_instance();

  static inline const ReplicaIdentityStmt* internal_default_instance() {
    return reinterpret_cast<const ReplicaIdentityStmt*>(
               &_ReplicaIdentityStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    163;

  friend void swap(ReplicaIdentityStmt& a, ReplicaIdentityStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ReplicaIdentityStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ReplicaIdentityStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ReplicaIdentityStmt* New() const final {
    return CreateMaybeMessage<ReplicaIdentityStmt>(nullptr);
  }

  ReplicaIdentityStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ReplicaIdentityStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ReplicaIdentityStmt& from);
  void MergeFrom(const ReplicaIdentityStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReplicaIdentityStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ReplicaIdentityStmt";
  }
  protected:
  explicit ReplicaIdentityStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIdentityTypeFieldNumber = 1,
    kNameFieldNumber = 2,
  };
  // string identity_type = 1 [json_name = "identity_type"];
  void clear_identity_type();
  const std::string& identity_type() const;
  void set_identity_type(const std::string& value);
  void set_identity_type(std::string&& value);
  void set_identity_type(const char* value);
  void set_identity_type(const char* value, size_t size);
  std::string* mutable_identity_type();
  std::string* release_identity_type();
  void set_allocated_identity_type(std::string* identity_type);
  private:
  const std::string& _internal_identity_type() const;
  void _internal_set_identity_type(const std::string& value);
  std::string* _internal_mutable_identity_type();
  public:

  // string name = 2 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ReplicaIdentityStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr identity_type_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterSystemStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterSystemStmt) */ {
 public:
  inline AlterSystemStmt() : AlterSystemStmt(nullptr) {}
  virtual ~AlterSystemStmt();

  AlterSystemStmt(const AlterSystemStmt& from);
  AlterSystemStmt(AlterSystemStmt&& from) noexcept
    : AlterSystemStmt() {
    *this = ::std::move(from);
  }

  inline AlterSystemStmt& operator=(const AlterSystemStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterSystemStmt& operator=(AlterSystemStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterSystemStmt& default_instance();

  static inline const AlterSystemStmt* internal_default_instance() {
    return reinterpret_cast<const AlterSystemStmt*>(
               &_AlterSystemStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    164;

  friend void swap(AlterSystemStmt& a, AlterSystemStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterSystemStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterSystemStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline AlterSystemStmt* New() const final {
    return CreateMaybeMessage<AlterSystemStmt>(nullptr);
  }

  AlterSystemStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterSystemStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterSystemStmt& from);
  void MergeFrom(const AlterSystemStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterSystemStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterSystemStmt";
  }
  protected:
  explicit AlterSystemStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSetstmtFieldNumber = 1,
  };
  // .pg_query.VariableSetStmt setstmt = 1 [json_name = "setstmt"];
  bool has_setstmt() const;
  private:
  bool _internal_has_setstmt() const;
  public:
  void clear_setstmt();
  const ::pg_query::VariableSetStmt& setstmt() const;
  ::pg_query::VariableSetStmt* release_setstmt();
  ::pg_query::VariableSetStmt* mutable_setstmt();
  void set_allocated_setstmt(::pg_query::VariableSetStmt* setstmt);
  private:
  const ::pg_query::VariableSetStmt& _internal_setstmt() const;
  ::pg_query::VariableSetStmt* _internal_mutable_setstmt();
  public:
  void unsafe_arena_set_allocated_setstmt(
      ::pg_query::VariableSetStmt* setstmt);
  ::pg_query::VariableSetStmt* unsafe_arena_release_setstmt();

  // @@protoc_insertion_point(class_scope:pg_query.AlterSystemStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::VariableSetStmt* setstmt_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreatePolicyStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreatePolicyStmt) */ {
 public:
  inline CreatePolicyStmt() : CreatePolicyStmt(nullptr) {}
  virtual ~CreatePolicyStmt();

  CreatePolicyStmt(const CreatePolicyStmt& from);
  CreatePolicyStmt(CreatePolicyStmt&& from) noexcept
    : CreatePolicyStmt() {
    *this = ::std::move(from);
  }

  inline CreatePolicyStmt& operator=(const CreatePolicyStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreatePolicyStmt& operator=(CreatePolicyStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreatePolicyStmt& default_instance();

  static inline const CreatePolicyStmt* internal_default_instance() {
    return reinterpret_cast<const CreatePolicyStmt*>(
               &_CreatePolicyStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    165;

  friend void swap(CreatePolicyStmt& a, CreatePolicyStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreatePolicyStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreatePolicyStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreatePolicyStmt* New() const final {
    return CreateMaybeMessage<CreatePolicyStmt>(nullptr);
  }

  CreatePolicyStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreatePolicyStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreatePolicyStmt& from);
  void MergeFrom(const CreatePolicyStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreatePolicyStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreatePolicyStmt";
  }
  protected:
  explicit CreatePolicyStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRolesFieldNumber = 5,
    kPolicyNameFieldNumber = 1,
    kCmdNameFieldNumber = 3,
    kTableFieldNumber = 2,
    kQualFieldNumber = 6,
    kWithCheckFieldNumber = 7,
    kPermissiveFieldNumber = 4,
  };
  // repeated .pg_query.Node roles = 5 [json_name = "roles"];
  int roles_size() const;
  private:
  int _internal_roles_size() const;
  public:
  void clear_roles();
  ::pg_query::Node* mutable_roles(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_roles();
  private:
  const ::pg_query::Node& _internal_roles(int index) const;
  ::pg_query::Node* _internal_add_roles();
  public:
  const ::pg_query::Node& roles(int index) const;
  ::pg_query::Node* add_roles();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      roles() const;

  // string policy_name = 1 [json_name = "policy_name"];
  void clear_policy_name();
  const std::string& policy_name() const;
  void set_policy_name(const std::string& value);
  void set_policy_name(std::string&& value);
  void set_policy_name(const char* value);
  void set_policy_name(const char* value, size_t size);
  std::string* mutable_policy_name();
  std::string* release_policy_name();
  void set_allocated_policy_name(std::string* policy_name);
  private:
  const std::string& _internal_policy_name() const;
  void _internal_set_policy_name(const std::string& value);
  std::string* _internal_mutable_policy_name();
  public:

  // string cmd_name = 3 [json_name = "cmd_name"];
  void clear_cmd_name();
  const std::string& cmd_name() const;
  void set_cmd_name(const std::string& value);
  void set_cmd_name(std::string&& value);
  void set_cmd_name(const char* value);
  void set_cmd_name(const char* value, size_t size);
  std::string* mutable_cmd_name();
  std::string* release_cmd_name();
  void set_allocated_cmd_name(std::string* cmd_name);
  private:
  const std::string& _internal_cmd_name() const;
  void _internal_set_cmd_name(const std::string& value);
  std::string* _internal_mutable_cmd_name();
  public:

  // .pg_query.RangeVar table = 2 [json_name = "table"];
  bool has_table() const;
  private:
  bool _internal_has_table() const;
  public:
  void clear_table();
  const ::pg_query::RangeVar& table() const;
  ::pg_query::RangeVar* release_table();
  ::pg_query::RangeVar* mutable_table();
  void set_allocated_table(::pg_query::RangeVar* table);
  private:
  const ::pg_query::RangeVar& _internal_table() const;
  ::pg_query::RangeVar* _internal_mutable_table();
  public:
  void unsafe_arena_set_allocated_table(
      ::pg_query::RangeVar* table);
  ::pg_query::RangeVar* unsafe_arena_release_table();

  // .pg_query.Node qual = 6 [json_name = "qual"];
  bool has_qual() const;
  private:
  bool _internal_has_qual() const;
  public:
  void clear_qual();
  const ::pg_query::Node& qual() const;
  ::pg_query::Node* release_qual();
  ::pg_query::Node* mutable_qual();
  void set_allocated_qual(::pg_query::Node* qual);
  private:
  const ::pg_query::Node& _internal_qual() const;
  ::pg_query::Node* _internal_mutable_qual();
  public:
  void unsafe_arena_set_allocated_qual(
      ::pg_query::Node* qual);
  ::pg_query::Node* unsafe_arena_release_qual();

  // .pg_query.Node with_check = 7 [json_name = "with_check"];
  bool has_with_check() const;
  private:
  bool _internal_has_with_check() const;
  public:
  void clear_with_check();
  const ::pg_query::Node& with_check() const;
  ::pg_query::Node* release_with_check();
  ::pg_query::Node* mutable_with_check();
  void set_allocated_with_check(::pg_query::Node* with_check);
  private:
  const ::pg_query::Node& _internal_with_check() const;
  ::pg_query::Node* _internal_mutable_with_check();
  public:
  void unsafe_arena_set_allocated_with_check(
      ::pg_query::Node* with_check);
  ::pg_query::Node* unsafe_arena_release_with_check();

  // bool permissive = 4 [json_name = "permissive"];
  void clear_permissive();
  bool permissive() const;
  void set_permissive(bool value);
  private:
  bool _internal_permissive() const;
  void _internal_set_permissive(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreatePolicyStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > roles_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr policy_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cmd_name_;
  ::pg_query::RangeVar* table_;
  ::pg_query::Node* qual_;
  ::pg_query::Node* with_check_;
  bool permissive_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterPolicyStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterPolicyStmt) */ {
 public:
  inline AlterPolicyStmt() : AlterPolicyStmt(nullptr) {}
  virtual ~AlterPolicyStmt();

  AlterPolicyStmt(const AlterPolicyStmt& from);
  AlterPolicyStmt(AlterPolicyStmt&& from) noexcept
    : AlterPolicyStmt() {
    *this = ::std::move(from);
  }

  inline AlterPolicyStmt& operator=(const AlterPolicyStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterPolicyStmt& operator=(AlterPolicyStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterPolicyStmt& default_instance();

  static inline const AlterPolicyStmt* internal_default_instance() {
    return reinterpret_cast<const AlterPolicyStmt*>(
               &_AlterPolicyStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    166;

  friend void swap(AlterPolicyStmt& a, AlterPolicyStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterPolicyStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterPolicyStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline AlterPolicyStmt* New() const final {
    return CreateMaybeMessage<AlterPolicyStmt>(nullptr);
  }

  AlterPolicyStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterPolicyStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterPolicyStmt& from);
  void MergeFrom(const AlterPolicyStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterPolicyStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterPolicyStmt";
  }
  protected:
  explicit AlterPolicyStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRolesFieldNumber = 3,
    kPolicyNameFieldNumber = 1,
    kTableFieldNumber = 2,
    kQualFieldNumber = 4,
    kWithCheckFieldNumber = 5,
  };
  // repeated .pg_query.Node roles = 3 [json_name = "roles"];
  int roles_size() const;
  private:
  int _internal_roles_size() const;
  public:
  void clear_roles();
  ::pg_query::Node* mutable_roles(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_roles();
  private:
  const ::pg_query::Node& _internal_roles(int index) const;
  ::pg_query::Node* _internal_add_roles();
  public:
  const ::pg_query::Node& roles(int index) const;
  ::pg_query::Node* add_roles();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      roles() const;

  // string policy_name = 1 [json_name = "policy_name"];
  void clear_policy_name();
  const std::string& policy_name() const;
  void set_policy_name(const std::string& value);
  void set_policy_name(std::string&& value);
  void set_policy_name(const char* value);
  void set_policy_name(const char* value, size_t size);
  std::string* mutable_policy_name();
  std::string* release_policy_name();
  void set_allocated_policy_name(std::string* policy_name);
  private:
  const std::string& _internal_policy_name() const;
  void _internal_set_policy_name(const std::string& value);
  std::string* _internal_mutable_policy_name();
  public:

  // .pg_query.RangeVar table = 2 [json_name = "table"];
  bool has_table() const;
  private:
  bool _internal_has_table() const;
  public:
  void clear_table();
  const ::pg_query::RangeVar& table() const;
  ::pg_query::RangeVar* release_table();
  ::pg_query::RangeVar* mutable_table();
  void set_allocated_table(::pg_query::RangeVar* table);
  private:
  const ::pg_query::RangeVar& _internal_table() const;
  ::pg_query::RangeVar* _internal_mutable_table();
  public:
  void unsafe_arena_set_allocated_table(
      ::pg_query::RangeVar* table);
  ::pg_query::RangeVar* unsafe_arena_release_table();

  // .pg_query.Node qual = 4 [json_name = "qual"];
  bool has_qual() const;
  private:
  bool _internal_has_qual() const;
  public:
  void clear_qual();
  const ::pg_query::Node& qual() const;
  ::pg_query::Node* release_qual();
  ::pg_query::Node* mutable_qual();
  void set_allocated_qual(::pg_query::Node* qual);
  private:
  const ::pg_query::Node& _internal_qual() const;
  ::pg_query::Node* _internal_mutable_qual();
  public:
  void unsafe_arena_set_allocated_qual(
      ::pg_query::Node* qual);
  ::pg_query::Node* unsafe_arena_release_qual();

  // .pg_query.Node with_check = 5 [json_name = "with_check"];
  bool has_with_check() const;
  private:
  bool _internal_has_with_check() const;
  public:
  void clear_with_check();
  const ::pg_query::Node& with_check() const;
  ::pg_query::Node* release_with_check();
  ::pg_query::Node* mutable_with_check();
  void set_allocated_with_check(::pg_query::Node* with_check);
  private:
  const ::pg_query::Node& _internal_with_check() const;
  ::pg_query::Node* _internal_mutable_with_check();
  public:
  void unsafe_arena_set_allocated_with_check(
      ::pg_query::Node* with_check);
  ::pg_query::Node* unsafe_arena_release_with_check();

  // @@protoc_insertion_point(class_scope:pg_query.AlterPolicyStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > roles_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr policy_name_;
  ::pg_query::RangeVar* table_;
  ::pg_query::Node* qual_;
  ::pg_query::Node* with_check_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateTransformStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateTransformStmt) */ {
 public:
  inline CreateTransformStmt() : CreateTransformStmt(nullptr) {}
  virtual ~CreateTransformStmt();

  CreateTransformStmt(const CreateTransformStmt& from);
  CreateTransformStmt(CreateTransformStmt&& from) noexcept
    : CreateTransformStmt() {
    *this = ::std::move(from);
  }

  inline CreateTransformStmt& operator=(const CreateTransformStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateTransformStmt& operator=(CreateTransformStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateTransformStmt& default_instance();

  static inline const CreateTransformStmt* internal_default_instance() {
    return reinterpret_cast<const CreateTransformStmt*>(
               &_CreateTransformStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    167;

  friend void swap(CreateTransformStmt& a, CreateTransformStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateTransformStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateTransformStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreateTransformStmt* New() const final {
    return CreateMaybeMessage<CreateTransformStmt>(nullptr);
  }

  CreateTransformStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateTransformStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateTransformStmt& from);
  void MergeFrom(const CreateTransformStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateTransformStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateTransformStmt";
  }
  protected:
  explicit CreateTransformStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLangFieldNumber = 3,
    kTypeNameFieldNumber = 2,
    kFromsqlFieldNumber = 4,
    kTosqlFieldNumber = 5,
    kReplaceFieldNumber = 1,
  };
  // string lang = 3 [json_name = "lang"];
  void clear_lang();
  const std::string& lang() const;
  void set_lang(const std::string& value);
  void set_lang(std::string&& value);
  void set_lang(const char* value);
  void set_lang(const char* value, size_t size);
  std::string* mutable_lang();
  std::string* release_lang();
  void set_allocated_lang(std::string* lang);
  private:
  const std::string& _internal_lang() const;
  void _internal_set_lang(const std::string& value);
  std::string* _internal_mutable_lang();
  public:

  // .pg_query.TypeName type_name = 2 [json_name = "type_name"];
  bool has_type_name() const;
  private:
  bool _internal_has_type_name() const;
  public:
  void clear_type_name();
  const ::pg_query::TypeName& type_name() const;
  ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* type_name);
  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();
  public:
  void unsafe_arena_set_allocated_type_name(
      ::pg_query::TypeName* type_name);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  // .pg_query.ObjectWithArgs fromsql = 4 [json_name = "fromsql"];
  bool has_fromsql() const;
  private:
  bool _internal_has_fromsql() const;
  public:
  void clear_fromsql();
  const ::pg_query::ObjectWithArgs& fromsql() const;
  ::pg_query::ObjectWithArgs* release_fromsql();
  ::pg_query::ObjectWithArgs* mutable_fromsql();
  void set_allocated_fromsql(::pg_query::ObjectWithArgs* fromsql);
  private:
  const ::pg_query::ObjectWithArgs& _internal_fromsql() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_fromsql();
  public:
  void unsafe_arena_set_allocated_fromsql(
      ::pg_query::ObjectWithArgs* fromsql);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_fromsql();

  // .pg_query.ObjectWithArgs tosql = 5 [json_name = "tosql"];
  bool has_tosql() const;
  private:
  bool _internal_has_tosql() const;
  public:
  void clear_tosql();
  const ::pg_query::ObjectWithArgs& tosql() const;
  ::pg_query::ObjectWithArgs* release_tosql();
  ::pg_query::ObjectWithArgs* mutable_tosql();
  void set_allocated_tosql(::pg_query::ObjectWithArgs* tosql);
  private:
  const ::pg_query::ObjectWithArgs& _internal_tosql() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_tosql();
  public:
  void unsafe_arena_set_allocated_tosql(
      ::pg_query::ObjectWithArgs* tosql);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_tosql();

  // bool replace = 1 [json_name = "replace"];
  void clear_replace();
  bool replace() const;
  void set_replace(bool value);
  private:
  bool _internal_replace() const;
  void _internal_set_replace(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateTransformStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lang_;
  ::pg_query::TypeName* type_name_;
  ::pg_query::ObjectWithArgs* fromsql_;
  ::pg_query::ObjectWithArgs* tosql_;
  bool replace_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateAmStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateAmStmt) */ {
 public:
  inline CreateAmStmt() : CreateAmStmt(nullptr) {}
  virtual ~CreateAmStmt();

  CreateAmStmt(const CreateAmStmt& from);
  CreateAmStmt(CreateAmStmt&& from) noexcept
    : CreateAmStmt() {
    *this = ::std::move(from);
  }

  inline CreateAmStmt& operator=(const CreateAmStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateAmStmt& operator=(CreateAmStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateAmStmt& default_instance();

  static inline const CreateAmStmt* internal_default_instance() {
    return reinterpret_cast<const CreateAmStmt*>(
               &_CreateAmStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    168;

  friend void swap(CreateAmStmt& a, CreateAmStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateAmStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateAmStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreateAmStmt* New() const final {
    return CreateMaybeMessage<CreateAmStmt>(nullptr);
  }

  CreateAmStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateAmStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateAmStmt& from);
  void MergeFrom(const CreateAmStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateAmStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateAmStmt";
  }
  protected:
  explicit CreateAmStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kHandlerNameFieldNumber = 2,
    kAmnameFieldNumber = 1,
    kAmtypeFieldNumber = 3,
  };
  // repeated .pg_query.Node handler_name = 2 [json_name = "handler_name"];
  int handler_name_size() const;
  private:
  int _internal_handler_name_size() const;
  public:
  void clear_handler_name();
  ::pg_query::Node* mutable_handler_name(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_handler_name();
  private:
  const ::pg_query::Node& _internal_handler_name(int index) const;
  ::pg_query::Node* _internal_add_handler_name();
  public:
  const ::pg_query::Node& handler_name(int index) const;
  ::pg_query::Node* add_handler_name();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      handler_name() const;

  // string amname = 1 [json_name = "amname"];
  void clear_amname();
  const std::string& amname() const;
  void set_amname(const std::string& value);
  void set_amname(std::string&& value);
  void set_amname(const char* value);
  void set_amname(const char* value, size_t size);
  std::string* mutable_amname();
  std::string* release_amname();
  void set_allocated_amname(std::string* amname);
  private:
  const std::string& _internal_amname() const;
  void _internal_set_amname(const std::string& value);
  std::string* _internal_mutable_amname();
  public:

  // string amtype = 3 [json_name = "amtype"];
  void clear_amtype();
  const std::string& amtype() const;
  void set_amtype(const std::string& value);
  void set_amtype(std::string&& value);
  void set_amtype(const char* value);
  void set_amtype(const char* value, size_t size);
  std::string* mutable_amtype();
  std::string* release_amtype();
  void set_allocated_amtype(std::string* amtype);
  private:
  const std::string& _internal_amtype() const;
  void _internal_set_amtype(const std::string& value);
  std::string* _internal_mutable_amtype();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateAmStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > handler_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr amname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr amtype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreatePublicationStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreatePublicationStmt) */ {
 public:
  inline CreatePublicationStmt() : CreatePublicationStmt(nullptr) {}
  virtual ~CreatePublicationStmt();

  CreatePublicationStmt(const CreatePublicationStmt& from);
  CreatePublicationStmt(CreatePublicationStmt&& from) noexcept
    : CreatePublicationStmt() {
    *this = ::std::move(from);
  }

  inline CreatePublicationStmt& operator=(const CreatePublicationStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreatePublicationStmt& operator=(CreatePublicationStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreatePublicationStmt& default_instance();

  static inline const CreatePublicationStmt* internal_default_instance() {
    return reinterpret_cast<const CreatePublicationStmt*>(
               &_CreatePublicationStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    169;

  friend void swap(CreatePublicationStmt& a, CreatePublicationStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreatePublicationStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreatePublicationStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreatePublicationStmt* New() const final {
    return CreateMaybeMessage<CreatePublicationStmt>(nullptr);
  }

  CreatePublicationStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreatePublicationStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreatePublicationStmt& from);
  void MergeFrom(const CreatePublicationStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreatePublicationStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreatePublicationStmt";
  }
  protected:
  explicit CreatePublicationStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOptionsFieldNumber = 2,
    kTablesFieldNumber = 3,
    kPubnameFieldNumber = 1,
    kForAllTablesFieldNumber = 4,
  };
  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // repeated .pg_query.Node tables = 3 [json_name = "tables"];
  int tables_size() const;
  private:
  int _internal_tables_size() const;
  public:
  void clear_tables();
  ::pg_query::Node* mutable_tables(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_tables();
  private:
  const ::pg_query::Node& _internal_tables(int index) const;
  ::pg_query::Node* _internal_add_tables();
  public:
  const ::pg_query::Node& tables(int index) const;
  ::pg_query::Node* add_tables();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      tables() const;

  // string pubname = 1 [json_name = "pubname"];
  void clear_pubname();
  const std::string& pubname() const;
  void set_pubname(const std::string& value);
  void set_pubname(std::string&& value);
  void set_pubname(const char* value);
  void set_pubname(const char* value, size_t size);
  std::string* mutable_pubname();
  std::string* release_pubname();
  void set_allocated_pubname(std::string* pubname);
  private:
  const std::string& _internal_pubname() const;
  void _internal_set_pubname(const std::string& value);
  std::string* _internal_mutable_pubname();
  public:

  // bool for_all_tables = 4 [json_name = "for_all_tables"];
  void clear_for_all_tables();
  bool for_all_tables() const;
  void set_for_all_tables(bool value);
  private:
  bool _internal_for_all_tables() const;
  void _internal_set_for_all_tables(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreatePublicationStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > tables_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pubname_;
  bool for_all_tables_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterPublicationStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterPublicationStmt) */ {
 public:
  inline AlterPublicationStmt() : AlterPublicationStmt(nullptr) {}
  virtual ~AlterPublicationStmt();

  AlterPublicationStmt(const AlterPublicationStmt& from);
  AlterPublicationStmt(AlterPublicationStmt&& from) noexcept
    : AlterPublicationStmt() {
    *this = ::std::move(from);
  }

  inline AlterPublicationStmt& operator=(const AlterPublicationStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterPublicationStmt& operator=(AlterPublicationStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterPublicationStmt& default_instance();

  static inline const AlterPublicationStmt* internal_default_instance() {
    return reinterpret_cast<const AlterPublicationStmt*>(
               &_AlterPublicationStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    170;

  friend void swap(AlterPublicationStmt& a, AlterPublicationStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterPublicationStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterPublicationStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline AlterPublicationStmt* New() const final {
    return CreateMaybeMessage<AlterPublicationStmt>(nullptr);
  }

  AlterPublicationStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterPublicationStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterPublicationStmt& from);
  void MergeFrom(const AlterPublicationStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterPublicationStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterPublicationStmt";
  }
  protected:
  explicit AlterPublicationStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOptionsFieldNumber = 2,
    kTablesFieldNumber = 3,
    kPubnameFieldNumber = 1,
    kForAllTablesFieldNumber = 4,
    kTableActionFieldNumber = 5,
  };
  // repeated .pg_query.Node options = 2 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // repeated .pg_query.Node tables = 3 [json_name = "tables"];
  int tables_size() const;
  private:
  int _internal_tables_size() const;
  public:
  void clear_tables();
  ::pg_query::Node* mutable_tables(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_tables();
  private:
  const ::pg_query::Node& _internal_tables(int index) const;
  ::pg_query::Node* _internal_add_tables();
  public:
  const ::pg_query::Node& tables(int index) const;
  ::pg_query::Node* add_tables();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      tables() const;

  // string pubname = 1 [json_name = "pubname"];
  void clear_pubname();
  const std::string& pubname() const;
  void set_pubname(const std::string& value);
  void set_pubname(std::string&& value);
  void set_pubname(const char* value);
  void set_pubname(const char* value, size_t size);
  std::string* mutable_pubname();
  std::string* release_pubname();
  void set_allocated_pubname(std::string* pubname);
  private:
  const std::string& _internal_pubname() const;
  void _internal_set_pubname(const std::string& value);
  std::string* _internal_mutable_pubname();
  public:

  // bool for_all_tables = 4 [json_name = "for_all_tables"];
  void clear_for_all_tables();
  bool for_all_tables() const;
  void set_for_all_tables(bool value);
  private:
  bool _internal_for_all_tables() const;
  void _internal_set_for_all_tables(bool value);
  public:

  // .pg_query.DefElemAction table_action = 5 [json_name = "tableAction"];
  void clear_table_action();
  ::pg_query::DefElemAction table_action() const;
  void set_table_action(::pg_query::DefElemAction value);
  private:
  ::pg_query::DefElemAction _internal_table_action() const;
  void _internal_set_table_action(::pg_query::DefElemAction value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterPublicationStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > tables_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pubname_;
  bool for_all_tables_;
  int table_action_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateSubscriptionStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateSubscriptionStmt) */ {
 public:
  inline CreateSubscriptionStmt() : CreateSubscriptionStmt(nullptr) {}
  virtual ~CreateSubscriptionStmt();

  CreateSubscriptionStmt(const CreateSubscriptionStmt& from);
  CreateSubscriptionStmt(CreateSubscriptionStmt&& from) noexcept
    : CreateSubscriptionStmt() {
    *this = ::std::move(from);
  }

  inline CreateSubscriptionStmt& operator=(const CreateSubscriptionStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateSubscriptionStmt& operator=(CreateSubscriptionStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateSubscriptionStmt& default_instance();

  static inline const CreateSubscriptionStmt* internal_default_instance() {
    return reinterpret_cast<const CreateSubscriptionStmt*>(
               &_CreateSubscriptionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    171;

  friend void swap(CreateSubscriptionStmt& a, CreateSubscriptionStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateSubscriptionStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateSubscriptionStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreateSubscriptionStmt* New() const final {
    return CreateMaybeMessage<CreateSubscriptionStmt>(nullptr);
  }

  CreateSubscriptionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateSubscriptionStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateSubscriptionStmt& from);
  void MergeFrom(const CreateSubscriptionStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateSubscriptionStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateSubscriptionStmt";
  }
  protected:
  explicit CreateSubscriptionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPublicationFieldNumber = 3,
    kOptionsFieldNumber = 4,
    kSubnameFieldNumber = 1,
    kConninfoFieldNumber = 2,
  };
  // repeated .pg_query.Node publication = 3 [json_name = "publication"];
  int publication_size() const;
  private:
  int _internal_publication_size() const;
  public:
  void clear_publication();
  ::pg_query::Node* mutable_publication(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_publication();
  private:
  const ::pg_query::Node& _internal_publication(int index) const;
  ::pg_query::Node* _internal_add_publication();
  public:
  const ::pg_query::Node& publication(int index) const;
  ::pg_query::Node* add_publication();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      publication() const;

  // repeated .pg_query.Node options = 4 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string subname = 1 [json_name = "subname"];
  void clear_subname();
  const std::string& subname() const;
  void set_subname(const std::string& value);
  void set_subname(std::string&& value);
  void set_subname(const char* value);
  void set_subname(const char* value, size_t size);
  std::string* mutable_subname();
  std::string* release_subname();
  void set_allocated_subname(std::string* subname);
  private:
  const std::string& _internal_subname() const;
  void _internal_set_subname(const std::string& value);
  std::string* _internal_mutable_subname();
  public:

  // string conninfo = 2 [json_name = "conninfo"];
  void clear_conninfo();
  const std::string& conninfo() const;
  void set_conninfo(const std::string& value);
  void set_conninfo(std::string&& value);
  void set_conninfo(const char* value);
  void set_conninfo(const char* value, size_t size);
  std::string* mutable_conninfo();
  std::string* release_conninfo();
  void set_allocated_conninfo(std::string* conninfo);
  private:
  const std::string& _internal_conninfo() const;
  void _internal_set_conninfo(const std::string& value);
  std::string* _internal_mutable_conninfo();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateSubscriptionStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > publication_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conninfo_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterSubscriptionStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterSubscriptionStmt) */ {
 public:
  inline AlterSubscriptionStmt() : AlterSubscriptionStmt(nullptr) {}
  virtual ~AlterSubscriptionStmt();

  AlterSubscriptionStmt(const AlterSubscriptionStmt& from);
  AlterSubscriptionStmt(AlterSubscriptionStmt&& from) noexcept
    : AlterSubscriptionStmt() {
    *this = ::std::move(from);
  }

  inline AlterSubscriptionStmt& operator=(const AlterSubscriptionStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterSubscriptionStmt& operator=(AlterSubscriptionStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterSubscriptionStmt& default_instance();

  static inline const AlterSubscriptionStmt* internal_default_instance() {
    return reinterpret_cast<const AlterSubscriptionStmt*>(
               &_AlterSubscriptionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    172;

  friend void swap(AlterSubscriptionStmt& a, AlterSubscriptionStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterSubscriptionStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterSubscriptionStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline AlterSubscriptionStmt* New() const final {
    return CreateMaybeMessage<AlterSubscriptionStmt>(nullptr);
  }

  AlterSubscriptionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterSubscriptionStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterSubscriptionStmt& from);
  void MergeFrom(const AlterSubscriptionStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterSubscriptionStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterSubscriptionStmt";
  }
  protected:
  explicit AlterSubscriptionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPublicationFieldNumber = 4,
    kOptionsFieldNumber = 5,
    kSubnameFieldNumber = 2,
    kConninfoFieldNumber = 3,
    kKindFieldNumber = 1,
  };
  // repeated .pg_query.Node publication = 4 [json_name = "publication"];
  int publication_size() const;
  private:
  int _internal_publication_size() const;
  public:
  void clear_publication();
  ::pg_query::Node* mutable_publication(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_publication();
  private:
  const ::pg_query::Node& _internal_publication(int index) const;
  ::pg_query::Node* _internal_add_publication();
  public:
  const ::pg_query::Node& publication(int index) const;
  ::pg_query::Node* add_publication();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      publication() const;

  // repeated .pg_query.Node options = 5 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // string subname = 2 [json_name = "subname"];
  void clear_subname();
  const std::string& subname() const;
  void set_subname(const std::string& value);
  void set_subname(std::string&& value);
  void set_subname(const char* value);
  void set_subname(const char* value, size_t size);
  std::string* mutable_subname();
  std::string* release_subname();
  void set_allocated_subname(std::string* subname);
  private:
  const std::string& _internal_subname() const;
  void _internal_set_subname(const std::string& value);
  std::string* _internal_mutable_subname();
  public:

  // string conninfo = 3 [json_name = "conninfo"];
  void clear_conninfo();
  const std::string& conninfo() const;
  void set_conninfo(const std::string& value);
  void set_conninfo(std::string&& value);
  void set_conninfo(const char* value);
  void set_conninfo(const char* value, size_t size);
  std::string* mutable_conninfo();
  std::string* release_conninfo();
  void set_allocated_conninfo(std::string* conninfo);
  private:
  const std::string& _internal_conninfo() const;
  void _internal_set_conninfo(const std::string& value);
  std::string* _internal_mutable_conninfo();
  public:

  // .pg_query.AlterSubscriptionType kind = 1 [json_name = "kind"];
  void clear_kind();
  ::pg_query::AlterSubscriptionType kind() const;
  void set_kind(::pg_query::AlterSubscriptionType value);
  private:
  ::pg_query::AlterSubscriptionType _internal_kind() const;
  void _internal_set_kind(::pg_query::AlterSubscriptionType value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterSubscriptionStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > publication_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conninfo_;
  int kind_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class DropSubscriptionStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropSubscriptionStmt) */ {
 public:
  inline DropSubscriptionStmt() : DropSubscriptionStmt(nullptr) {}
  virtual ~DropSubscriptionStmt();

  DropSubscriptionStmt(const DropSubscriptionStmt& from);
  DropSubscriptionStmt(DropSubscriptionStmt&& from) noexcept
    : DropSubscriptionStmt() {
    *this = ::std::move(from);
  }

  inline DropSubscriptionStmt& operator=(const DropSubscriptionStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline DropSubscriptionStmt& operator=(DropSubscriptionStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DropSubscriptionStmt& default_instance();

  static inline const DropSubscriptionStmt* internal_default_instance() {
    return reinterpret_cast<const DropSubscriptionStmt*>(
               &_DropSubscriptionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    173;

  friend void swap(DropSubscriptionStmt& a, DropSubscriptionStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(DropSubscriptionStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DropSubscriptionStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline DropSubscriptionStmt* New() const final {
    return CreateMaybeMessage<DropSubscriptionStmt>(nullptr);
  }

  DropSubscriptionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DropSubscriptionStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DropSubscriptionStmt& from);
  void MergeFrom(const DropSubscriptionStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DropSubscriptionStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DropSubscriptionStmt";
  }
  protected:
  explicit DropSubscriptionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSubnameFieldNumber = 1,
    kMissingOkFieldNumber = 2,
    kBehaviorFieldNumber = 3,
  };
  // string subname = 1 [json_name = "subname"];
  void clear_subname();
  const std::string& subname() const;
  void set_subname(const std::string& value);
  void set_subname(std::string&& value);
  void set_subname(const char* value);
  void set_subname(const char* value, size_t size);
  std::string* mutable_subname();
  std::string* release_subname();
  void set_allocated_subname(std::string* subname);
  private:
  const std::string& _internal_subname() const;
  void _internal_set_subname(const std::string& value);
  std::string* _internal_mutable_subname();
  public:

  // bool missing_ok = 2 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // .pg_query.DropBehavior behavior = 3 [json_name = "behavior"];
  void clear_behavior();
  ::pg_query::DropBehavior behavior() const;
  void set_behavior(::pg_query::DropBehavior value);
  private:
  ::pg_query::DropBehavior _internal_behavior() const;
  void _internal_set_behavior(::pg_query::DropBehavior value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.DropSubscriptionStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subname_;
  bool missing_ok_;
  int behavior_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateStatsStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateStatsStmt) */ {
 public:
  inline CreateStatsStmt() : CreateStatsStmt(nullptr) {}
  virtual ~CreateStatsStmt();

  CreateStatsStmt(const CreateStatsStmt& from);
  CreateStatsStmt(CreateStatsStmt&& from) noexcept
    : CreateStatsStmt() {
    *this = ::std::move(from);
  }

  inline CreateStatsStmt& operator=(const CreateStatsStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateStatsStmt& operator=(CreateStatsStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateStatsStmt& default_instance();

  static inline const CreateStatsStmt* internal_default_instance() {
    return reinterpret_cast<const CreateStatsStmt*>(
               &_CreateStatsStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    174;

  friend void swap(CreateStatsStmt& a, CreateStatsStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateStatsStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateStatsStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreateStatsStmt* New() const final {
    return CreateMaybeMessage<CreateStatsStmt>(nullptr);
  }

  CreateStatsStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateStatsStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateStatsStmt& from);
  void MergeFrom(const CreateStatsStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateStatsStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateStatsStmt";
  }
  protected:
  explicit CreateStatsStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDefnamesFieldNumber = 1,
    kStatTypesFieldNumber = 2,
    kExprsFieldNumber = 3,
    kRelationsFieldNumber = 4,
    kStxcommentFieldNumber = 5,
    kIfNotExistsFieldNumber = 6,
  };
  // repeated .pg_query.Node defnames = 1 [json_name = "defnames"];
  int defnames_size() const;
  private:
  int _internal_defnames_size() const;
  public:
  void clear_defnames();
  ::pg_query::Node* mutable_defnames(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_defnames();
  private:
  const ::pg_query::Node& _internal_defnames(int index) const;
  ::pg_query::Node* _internal_add_defnames();
  public:
  const ::pg_query::Node& defnames(int index) const;
  ::pg_query::Node* add_defnames();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      defnames() const;

  // repeated .pg_query.Node stat_types = 2 [json_name = "stat_types"];
  int stat_types_size() const;
  private:
  int _internal_stat_types_size() const;
  public:
  void clear_stat_types();
  ::pg_query::Node* mutable_stat_types(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_stat_types();
  private:
  const ::pg_query::Node& _internal_stat_types(int index) const;
  ::pg_query::Node* _internal_add_stat_types();
  public:
  const ::pg_query::Node& stat_types(int index) const;
  ::pg_query::Node* add_stat_types();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      stat_types() const;

  // repeated .pg_query.Node exprs = 3 [json_name = "exprs"];
  int exprs_size() const;
  private:
  int _internal_exprs_size() const;
  public:
  void clear_exprs();
  ::pg_query::Node* mutable_exprs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_exprs();
  private:
  const ::pg_query::Node& _internal_exprs(int index) const;
  ::pg_query::Node* _internal_add_exprs();
  public:
  const ::pg_query::Node& exprs(int index) const;
  ::pg_query::Node* add_exprs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      exprs() const;

  // repeated .pg_query.Node relations = 4 [json_name = "relations"];
  int relations_size() const;
  private:
  int _internal_relations_size() const;
  public:
  void clear_relations();
  ::pg_query::Node* mutable_relations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_relations();
  private:
  const ::pg_query::Node& _internal_relations(int index) const;
  ::pg_query::Node* _internal_add_relations();
  public:
  const ::pg_query::Node& relations(int index) const;
  ::pg_query::Node* add_relations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      relations() const;

  // string stxcomment = 5 [json_name = "stxcomment"];
  void clear_stxcomment();
  const std::string& stxcomment() const;
  void set_stxcomment(const std::string& value);
  void set_stxcomment(std::string&& value);
  void set_stxcomment(const char* value);
  void set_stxcomment(const char* value, size_t size);
  std::string* mutable_stxcomment();
  std::string* release_stxcomment();
  void set_allocated_stxcomment(std::string* stxcomment);
  private:
  const std::string& _internal_stxcomment() const;
  void _internal_set_stxcomment(const std::string& value);
  std::string* _internal_mutable_stxcomment();
  public:

  // bool if_not_exists = 6 [json_name = "if_not_exists"];
  void clear_if_not_exists();
  bool if_not_exists() const;
  void set_if_not_exists(bool value);
  private:
  bool _internal_if_not_exists() const;
  void _internal_set_if_not_exists(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateStatsStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > defnames_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > stat_types_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > exprs_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > relations_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stxcomment_;
  bool if_not_exists_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterCollationStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterCollationStmt) */ {
 public:
  inline AlterCollationStmt() : AlterCollationStmt(nullptr) {}
  virtual ~AlterCollationStmt();

  AlterCollationStmt(const AlterCollationStmt& from);
  AlterCollationStmt(AlterCollationStmt&& from) noexcept
    : AlterCollationStmt() {
    *this = ::std::move(from);
  }

  inline AlterCollationStmt& operator=(const AlterCollationStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterCollationStmt& operator=(AlterCollationStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterCollationStmt& default_instance();

  static inline const AlterCollationStmt* internal_default_instance() {
    return reinterpret_cast<const AlterCollationStmt*>(
               &_AlterCollationStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    175;

  friend void swap(AlterCollationStmt& a, AlterCollationStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterCollationStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterCollationStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline AlterCollationStmt* New() const final {
    return CreateMaybeMessage<AlterCollationStmt>(nullptr);
  }

  AlterCollationStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterCollationStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterCollationStmt& from);
  void MergeFrom(const AlterCollationStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterCollationStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterCollationStmt";
  }
  protected:
  explicit AlterCollationStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCollnameFieldNumber = 1,
  };
  // repeated .pg_query.Node collname = 1 [json_name = "collname"];
  int collname_size() const;
  private:
  int _internal_collname_size() const;
  public:
  void clear_collname();
  ::pg_query::Node* mutable_collname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_collname();
  private:
  const ::pg_query::Node& _internal_collname(int index) const;
  ::pg_query::Node* _internal_add_collname();
  public:
  const ::pg_query::Node& collname(int index) const;
  ::pg_query::Node* add_collname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      collname() const;

  // @@protoc_insertion_point(class_scope:pg_query.AlterCollationStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > collname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CallStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CallStmt) */ {
 public:
  inline CallStmt() : CallStmt(nullptr) {}
  virtual ~CallStmt();

  CallStmt(const CallStmt& from);
  CallStmt(CallStmt&& from) noexcept
    : CallStmt() {
    *this = ::std::move(from);
  }

  inline CallStmt& operator=(const CallStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CallStmt& operator=(CallStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CallStmt& default_instance();

  static inline const CallStmt* internal_default_instance() {
    return reinterpret_cast<const CallStmt*>(
               &_CallStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    176;

  friend void swap(CallStmt& a, CallStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(CallStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CallStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CallStmt* New() const final {
    return CreateMaybeMessage<CallStmt>(nullptr);
  }

  CallStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CallStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CallStmt& from);
  void MergeFrom(const CallStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CallStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CallStmt";
  }
  protected:
  explicit CallStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFunccallFieldNumber = 1,
    kFuncexprFieldNumber = 2,
  };
  // .pg_query.FuncCall funccall = 1 [json_name = "funccall"];
  bool has_funccall() const;
  private:
  bool _internal_has_funccall() const;
  public:
  void clear_funccall();
  const ::pg_query::FuncCall& funccall() const;
  ::pg_query::FuncCall* release_funccall();
  ::pg_query::FuncCall* mutable_funccall();
  void set_allocated_funccall(::pg_query::FuncCall* funccall);
  private:
  const ::pg_query::FuncCall& _internal_funccall() const;
  ::pg_query::FuncCall* _internal_mutable_funccall();
  public:
  void unsafe_arena_set_allocated_funccall(
      ::pg_query::FuncCall* funccall);
  ::pg_query::FuncCall* unsafe_arena_release_funccall();

  // .pg_query.FuncExpr funcexpr = 2 [json_name = "funcexpr"];
  bool has_funcexpr() const;
  private:
  bool _internal_has_funcexpr() const;
  public:
  void clear_funcexpr();
  const ::pg_query::FuncExpr& funcexpr() const;
  ::pg_query::FuncExpr* release_funcexpr();
  ::pg_query::FuncExpr* mutable_funcexpr();
  void set_allocated_funcexpr(::pg_query::FuncExpr* funcexpr);
  private:
  const ::pg_query::FuncExpr& _internal_funcexpr() const;
  ::pg_query::FuncExpr* _internal_mutable_funcexpr();
  public:
  void unsafe_arena_set_allocated_funcexpr(
      ::pg_query::FuncExpr* funcexpr);
  ::pg_query::FuncExpr* unsafe_arena_release_funcexpr();

  // @@protoc_insertion_point(class_scope:pg_query.CallStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::FuncCall* funccall_;
  ::pg_query::FuncExpr* funcexpr_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AlterStatsStmt PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterStatsStmt) */ {
 public:
  inline AlterStatsStmt() : AlterStatsStmt(nullptr) {}
  virtual ~AlterStatsStmt();

  AlterStatsStmt(const AlterStatsStmt& from);
  AlterStatsStmt(AlterStatsStmt&& from) noexcept
    : AlterStatsStmt() {
    *this = ::std::move(from);
  }

  inline AlterStatsStmt& operator=(const AlterStatsStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlterStatsStmt& operator=(AlterStatsStmt&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlterStatsStmt& default_instance();

  static inline const AlterStatsStmt* internal_default_instance() {
    return reinterpret_cast<const AlterStatsStmt*>(
               &_AlterStatsStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    177;

  friend void swap(AlterStatsStmt& a, AlterStatsStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(AlterStatsStmt* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlterStatsStmt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline AlterStatsStmt* New() const final {
    return CreateMaybeMessage<AlterStatsStmt>(nullptr);
  }

  AlterStatsStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlterStatsStmt>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlterStatsStmt& from);
  void MergeFrom(const AlterStatsStmt& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlterStatsStmt* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AlterStatsStmt";
  }
  protected:
  explicit AlterStatsStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDefnamesFieldNumber = 1,
    kStxstattargetFieldNumber = 2,
    kMissingOkFieldNumber = 3,
  };
  // repeated .pg_query.Node defnames = 1 [json_name = "defnames"];
  int defnames_size() const;
  private:
  int _internal_defnames_size() const;
  public:
  void clear_defnames();
  ::pg_query::Node* mutable_defnames(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_defnames();
  private:
  const ::pg_query::Node& _internal_defnames(int index) const;
  ::pg_query::Node* _internal_add_defnames();
  public:
  const ::pg_query::Node& defnames(int index) const;
  ::pg_query::Node* add_defnames();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      defnames() const;

  // int32 stxstattarget = 2 [json_name = "stxstattarget"];
  void clear_stxstattarget();
  ::PROTOBUF_NAMESPACE_ID::int32 stxstattarget() const;
  void set_stxstattarget(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_stxstattarget() const;
  void _internal_set_stxstattarget(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool missing_ok = 3 [json_name = "missing_ok"];
  void clear_missing_ok();
  bool missing_ok() const;
  void set_missing_ok(bool value);
  private:
  bool _internal_missing_ok() const;
  void _internal_set_missing_ok(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AlterStatsStmt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > defnames_;
  ::PROTOBUF_NAMESPACE_ID::int32 stxstattarget_;
  bool missing_ok_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class A_Expr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.A_Expr) */ {
 public:
  inline A_Expr() : A_Expr(nullptr) {}
  virtual ~A_Expr();

  A_Expr(const A_Expr& from);
  A_Expr(A_Expr&& from) noexcept
    : A_Expr() {
    *this = ::std::move(from);
  }

  inline A_Expr& operator=(const A_Expr& from) {
    CopyFrom(from);
    return *this;
  }
  inline A_Expr& operator=(A_Expr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const A_Expr& default_instance();

  static inline const A_Expr* internal_default_instance() {
    return reinterpret_cast<const A_Expr*>(
               &_A_Expr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    178;

  friend void swap(A_Expr& a, A_Expr& b) {
    a.Swap(&b);
  }
  inline void Swap(A_Expr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(A_Expr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline A_Expr* New() const final {
    return CreateMaybeMessage<A_Expr>(nullptr);
  }

  A_Expr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<A_Expr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const A_Expr& from);
  void MergeFrom(const A_Expr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(A_Expr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.A_Expr";
  }
  protected:
  explicit A_Expr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 2,
    kLexprFieldNumber = 3,
    kRexprFieldNumber = 4,
    kKindFieldNumber = 1,
    kLocationFieldNumber = 5,
  };
  // repeated .pg_query.Node name = 2 [json_name = "name"];
  int name_size() const;
  private:
  int _internal_name_size() const;
  public:
  void clear_name();
  ::pg_query::Node* mutable_name(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_name();
  private:
  const ::pg_query::Node& _internal_name(int index) const;
  ::pg_query::Node* _internal_add_name();
  public:
  const ::pg_query::Node& name(int index) const;
  ::pg_query::Node* add_name();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      name() const;

  // .pg_query.Node lexpr = 3 [json_name = "lexpr"];
  bool has_lexpr() const;
  private:
  bool _internal_has_lexpr() const;
  public:
  void clear_lexpr();
  const ::pg_query::Node& lexpr() const;
  ::pg_query::Node* release_lexpr();
  ::pg_query::Node* mutable_lexpr();
  void set_allocated_lexpr(::pg_query::Node* lexpr);
  private:
  const ::pg_query::Node& _internal_lexpr() const;
  ::pg_query::Node* _internal_mutable_lexpr();
  public:
  void unsafe_arena_set_allocated_lexpr(
      ::pg_query::Node* lexpr);
  ::pg_query::Node* unsafe_arena_release_lexpr();

  // .pg_query.Node rexpr = 4 [json_name = "rexpr"];
  bool has_rexpr() const;
  private:
  bool _internal_has_rexpr() const;
  public:
  void clear_rexpr();
  const ::pg_query::Node& rexpr() const;
  ::pg_query::Node* release_rexpr();
  ::pg_query::Node* mutable_rexpr();
  void set_allocated_rexpr(::pg_query::Node* rexpr);
  private:
  const ::pg_query::Node& _internal_rexpr() const;
  ::pg_query::Node* _internal_mutable_rexpr();
  public:
  void unsafe_arena_set_allocated_rexpr(
      ::pg_query::Node* rexpr);
  ::pg_query::Node* unsafe_arena_release_rexpr();

  // .pg_query.A_Expr_Kind kind = 1 [json_name = "kind"];
  void clear_kind();
  ::pg_query::A_Expr_Kind kind() const;
  void set_kind(::pg_query::A_Expr_Kind value);
  private:
  ::pg_query::A_Expr_Kind _internal_kind() const;
  void _internal_set_kind(::pg_query::A_Expr_Kind value);
  public:

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.A_Expr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > name_;
  ::pg_query::Node* lexpr_;
  ::pg_query::Node* rexpr_;
  int kind_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ColumnRef PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ColumnRef) */ {
 public:
  inline ColumnRef() : ColumnRef(nullptr) {}
  virtual ~ColumnRef();

  ColumnRef(const ColumnRef& from);
  ColumnRef(ColumnRef&& from) noexcept
    : ColumnRef() {
    *this = ::std::move(from);
  }

  inline ColumnRef& operator=(const ColumnRef& from) {
    CopyFrom(from);
    return *this;
  }
  inline ColumnRef& operator=(ColumnRef&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ColumnRef& default_instance();

  static inline const ColumnRef* internal_default_instance() {
    return reinterpret_cast<const ColumnRef*>(
               &_ColumnRef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    179;

  friend void swap(ColumnRef& a, ColumnRef& b) {
    a.Swap(&b);
  }
  inline void Swap(ColumnRef* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ColumnRef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ColumnRef* New() const final {
    return CreateMaybeMessage<ColumnRef>(nullptr);
  }

  ColumnRef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ColumnRef>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ColumnRef& from);
  void MergeFrom(const ColumnRef& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ColumnRef* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ColumnRef";
  }
  protected:
  explicit ColumnRef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFieldsFieldNumber = 1,
    kLocationFieldNumber = 2,
  };
  // repeated .pg_query.Node fields = 1 [json_name = "fields"];
  int fields_size() const;
  private:
  int _internal_fields_size() const;
  public:
  void clear_fields();
  ::pg_query::Node* mutable_fields(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_fields();
  private:
  const ::pg_query::Node& _internal_fields(int index) const;
  ::pg_query::Node* _internal_add_fields();
  public:
  const ::pg_query::Node& fields(int index) const;
  ::pg_query::Node* add_fields();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      fields() const;

  // int32 location = 2 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ColumnRef)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > fields_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ParamRef PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ParamRef) */ {
 public:
  inline ParamRef() : ParamRef(nullptr) {}
  virtual ~ParamRef();

  ParamRef(const ParamRef& from);
  ParamRef(ParamRef&& from) noexcept
    : ParamRef() {
    *this = ::std::move(from);
  }

  inline ParamRef& operator=(const ParamRef& from) {
    CopyFrom(from);
    return *this;
  }
  inline ParamRef& operator=(ParamRef&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ParamRef& default_instance();

  static inline const ParamRef* internal_default_instance() {
    return reinterpret_cast<const ParamRef*>(
               &_ParamRef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    180;

  friend void swap(ParamRef& a, ParamRef& b) {
    a.Swap(&b);
  }
  inline void Swap(ParamRef* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ParamRef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ParamRef* New() const final {
    return CreateMaybeMessage<ParamRef>(nullptr);
  }

  ParamRef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ParamRef>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ParamRef& from);
  void MergeFrom(const ParamRef& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ParamRef* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ParamRef";
  }
  protected:
  explicit ParamRef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNumberFieldNumber = 1,
    kLocationFieldNumber = 2,
  };
  // int32 number = 1 [json_name = "number"];
  void clear_number();
  ::PROTOBUF_NAMESPACE_ID::int32 number() const;
  void set_number(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_number() const;
  void _internal_set_number(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 location = 2 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ParamRef)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int32 number_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class A_Const PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.A_Const) */ {
 public:
  inline A_Const() : A_Const(nullptr) {}
  virtual ~A_Const();

  A_Const(const A_Const& from);
  A_Const(A_Const&& from) noexcept
    : A_Const() {
    *this = ::std::move(from);
  }

  inline A_Const& operator=(const A_Const& from) {
    CopyFrom(from);
    return *this;
  }
  inline A_Const& operator=(A_Const&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const A_Const& default_instance();

  static inline const A_Const* internal_default_instance() {
    return reinterpret_cast<const A_Const*>(
               &_A_Const_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    181;

  friend void swap(A_Const& a, A_Const& b) {
    a.Swap(&b);
  }
  inline void Swap(A_Const* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(A_Const* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline A_Const* New() const final {
    return CreateMaybeMessage<A_Const>(nullptr);
  }

  A_Const* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<A_Const>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const A_Const& from);
  void MergeFrom(const A_Const& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(A_Const* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.A_Const";
  }
  protected:
  explicit A_Const(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValFieldNumber = 1,
    kLocationFieldNumber = 2,
  };
  // .pg_query.Node val = 1 [json_name = "val"];
  bool has_val() const;
  private:
  bool _internal_has_val() const;
  public:
  void clear_val();
  const ::pg_query::Node& val() const;
  ::pg_query::Node* release_val();
  ::pg_query::Node* mutable_val();
  void set_allocated_val(::pg_query::Node* val);
  private:
  const ::pg_query::Node& _internal_val() const;
  ::pg_query::Node* _internal_mutable_val();
  public:
  void unsafe_arena_set_allocated_val(
      ::pg_query::Node* val);
  ::pg_query::Node* unsafe_arena_release_val();

  // int32 location = 2 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.A_Const)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* val_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class FuncCall PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FuncCall) */ {
 public:
  inline FuncCall() : FuncCall(nullptr) {}
  virtual ~FuncCall();

  FuncCall(const FuncCall& from);
  FuncCall(FuncCall&& from) noexcept
    : FuncCall() {
    *this = ::std::move(from);
  }

  inline FuncCall& operator=(const FuncCall& from) {
    CopyFrom(from);
    return *this;
  }
  inline FuncCall& operator=(FuncCall&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const FuncCall& default_instance();

  static inline const FuncCall* internal_default_instance() {
    return reinterpret_cast<const FuncCall*>(
               &_FuncCall_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    182;

  friend void swap(FuncCall& a, FuncCall& b) {
    a.Swap(&b);
  }
  inline void Swap(FuncCall* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FuncCall* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline FuncCall* New() const final {
    return CreateMaybeMessage<FuncCall>(nullptr);
  }

  FuncCall* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FuncCall>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const FuncCall& from);
  void MergeFrom(const FuncCall& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FuncCall* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.FuncCall";
  }
  protected:
  explicit FuncCall(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFuncnameFieldNumber = 1,
    kArgsFieldNumber = 2,
    kAggOrderFieldNumber = 3,
    kAggFilterFieldNumber = 4,
    kOverFieldNumber = 9,
    kAggWithinGroupFieldNumber = 5,
    kAggStarFieldNumber = 6,
    kAggDistinctFieldNumber = 7,
    kFuncVariadicFieldNumber = 8,
    kLocationFieldNumber = 10,
  };
  // repeated .pg_query.Node funcname = 1 [json_name = "funcname"];
  int funcname_size() const;
  private:
  int _internal_funcname_size() const;
  public:
  void clear_funcname();
  ::pg_query::Node* mutable_funcname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_funcname();
  private:
  const ::pg_query::Node& _internal_funcname(int index) const;
  ::pg_query::Node* _internal_add_funcname();
  public:
  const ::pg_query::Node& funcname(int index) const;
  ::pg_query::Node* add_funcname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      funcname() const;

  // repeated .pg_query.Node args = 2 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // repeated .pg_query.Node agg_order = 3 [json_name = "agg_order"];
  int agg_order_size() const;
  private:
  int _internal_agg_order_size() const;
  public:
  void clear_agg_order();
  ::pg_query::Node* mutable_agg_order(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_agg_order();
  private:
  const ::pg_query::Node& _internal_agg_order(int index) const;
  ::pg_query::Node* _internal_add_agg_order();
  public:
  const ::pg_query::Node& agg_order(int index) const;
  ::pg_query::Node* add_agg_order();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      agg_order() const;

  // .pg_query.Node agg_filter = 4 [json_name = "agg_filter"];
  bool has_agg_filter() const;
  private:
  bool _internal_has_agg_filter() const;
  public:
  void clear_agg_filter();
  const ::pg_query::Node& agg_filter() const;
  ::pg_query::Node* release_agg_filter();
  ::pg_query::Node* mutable_agg_filter();
  void set_allocated_agg_filter(::pg_query::Node* agg_filter);
  private:
  const ::pg_query::Node& _internal_agg_filter() const;
  ::pg_query::Node* _internal_mutable_agg_filter();
  public:
  void unsafe_arena_set_allocated_agg_filter(
      ::pg_query::Node* agg_filter);
  ::pg_query::Node* unsafe_arena_release_agg_filter();

  // .pg_query.WindowDef over = 9 [json_name = "over"];
  bool has_over() const;
  private:
  bool _internal_has_over() const;
  public:
  void clear_over();
  const ::pg_query::WindowDef& over() const;
  ::pg_query::WindowDef* release_over();
  ::pg_query::WindowDef* mutable_over();
  void set_allocated_over(::pg_query::WindowDef* over);
  private:
  const ::pg_query::WindowDef& _internal_over() const;
  ::pg_query::WindowDef* _internal_mutable_over();
  public:
  void unsafe_arena_set_allocated_over(
      ::pg_query::WindowDef* over);
  ::pg_query::WindowDef* unsafe_arena_release_over();

  // bool agg_within_group = 5 [json_name = "agg_within_group"];
  void clear_agg_within_group();
  bool agg_within_group() const;
  void set_agg_within_group(bool value);
  private:
  bool _internal_agg_within_group() const;
  void _internal_set_agg_within_group(bool value);
  public:

  // bool agg_star = 6 [json_name = "agg_star"];
  void clear_agg_star();
  bool agg_star() const;
  void set_agg_star(bool value);
  private:
  bool _internal_agg_star() const;
  void _internal_set_agg_star(bool value);
  public:

  // bool agg_distinct = 7 [json_name = "agg_distinct"];
  void clear_agg_distinct();
  bool agg_distinct() const;
  void set_agg_distinct(bool value);
  private:
  bool _internal_agg_distinct() const;
  void _internal_set_agg_distinct(bool value);
  public:

  // bool func_variadic = 8 [json_name = "func_variadic"];
  void clear_func_variadic();
  bool func_variadic() const;
  void set_func_variadic(bool value);
  private:
  bool _internal_func_variadic() const;
  void _internal_set_func_variadic(bool value);
  public:

  // int32 location = 10 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.FuncCall)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funcname_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > agg_order_;
  ::pg_query::Node* agg_filter_;
  ::pg_query::WindowDef* over_;
  bool agg_within_group_;
  bool agg_star_;
  bool agg_distinct_;
  bool func_variadic_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class A_Star PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.A_Star) */ {
 public:
  inline A_Star() : A_Star(nullptr) {}
  virtual ~A_Star();

  A_Star(const A_Star& from);
  A_Star(A_Star&& from) noexcept
    : A_Star() {
    *this = ::std::move(from);
  }

  inline A_Star& operator=(const A_Star& from) {
    CopyFrom(from);
    return *this;
  }
  inline A_Star& operator=(A_Star&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const A_Star& default_instance();

  static inline const A_Star* internal_default_instance() {
    return reinterpret_cast<const A_Star*>(
               &_A_Star_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    183;

  friend void swap(A_Star& a, A_Star& b) {
    a.Swap(&b);
  }
  inline void Swap(A_Star* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(A_Star* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline A_Star* New() const final {
    return CreateMaybeMessage<A_Star>(nullptr);
  }

  A_Star* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<A_Star>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const A_Star& from);
  void MergeFrom(const A_Star& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(A_Star* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.A_Star";
  }
  protected:
  explicit A_Star(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:pg_query.A_Star)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class A_Indices PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.A_Indices) */ {
 public:
  inline A_Indices() : A_Indices(nullptr) {}
  virtual ~A_Indices();

  A_Indices(const A_Indices& from);
  A_Indices(A_Indices&& from) noexcept
    : A_Indices() {
    *this = ::std::move(from);
  }

  inline A_Indices& operator=(const A_Indices& from) {
    CopyFrom(from);
    return *this;
  }
  inline A_Indices& operator=(A_Indices&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const A_Indices& default_instance();

  static inline const A_Indices* internal_default_instance() {
    return reinterpret_cast<const A_Indices*>(
               &_A_Indices_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    184;

  friend void swap(A_Indices& a, A_Indices& b) {
    a.Swap(&b);
  }
  inline void Swap(A_Indices* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(A_Indices* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline A_Indices* New() const final {
    return CreateMaybeMessage<A_Indices>(nullptr);
  }

  A_Indices* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<A_Indices>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const A_Indices& from);
  void MergeFrom(const A_Indices& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(A_Indices* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.A_Indices";
  }
  protected:
  explicit A_Indices(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLidxFieldNumber = 2,
    kUidxFieldNumber = 3,
    kIsSliceFieldNumber = 1,
  };
  // .pg_query.Node lidx = 2 [json_name = "lidx"];
  bool has_lidx() const;
  private:
  bool _internal_has_lidx() const;
  public:
  void clear_lidx();
  const ::pg_query::Node& lidx() const;
  ::pg_query::Node* release_lidx();
  ::pg_query::Node* mutable_lidx();
  void set_allocated_lidx(::pg_query::Node* lidx);
  private:
  const ::pg_query::Node& _internal_lidx() const;
  ::pg_query::Node* _internal_mutable_lidx();
  public:
  void unsafe_arena_set_allocated_lidx(
      ::pg_query::Node* lidx);
  ::pg_query::Node* unsafe_arena_release_lidx();

  // .pg_query.Node uidx = 3 [json_name = "uidx"];
  bool has_uidx() const;
  private:
  bool _internal_has_uidx() const;
  public:
  void clear_uidx();
  const ::pg_query::Node& uidx() const;
  ::pg_query::Node* release_uidx();
  ::pg_query::Node* mutable_uidx();
  void set_allocated_uidx(::pg_query::Node* uidx);
  private:
  const ::pg_query::Node& _internal_uidx() const;
  ::pg_query::Node* _internal_mutable_uidx();
  public:
  void unsafe_arena_set_allocated_uidx(
      ::pg_query::Node* uidx);
  ::pg_query::Node* unsafe_arena_release_uidx();

  // bool is_slice = 1 [json_name = "is_slice"];
  void clear_is_slice();
  bool is_slice() const;
  void set_is_slice(bool value);
  private:
  bool _internal_is_slice() const;
  void _internal_set_is_slice(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.A_Indices)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* lidx_;
  ::pg_query::Node* uidx_;
  bool is_slice_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class A_Indirection PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.A_Indirection) */ {
 public:
  inline A_Indirection() : A_Indirection(nullptr) {}
  virtual ~A_Indirection();

  A_Indirection(const A_Indirection& from);
  A_Indirection(A_Indirection&& from) noexcept
    : A_Indirection() {
    *this = ::std::move(from);
  }

  inline A_Indirection& operator=(const A_Indirection& from) {
    CopyFrom(from);
    return *this;
  }
  inline A_Indirection& operator=(A_Indirection&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const A_Indirection& default_instance();

  static inline const A_Indirection* internal_default_instance() {
    return reinterpret_cast<const A_Indirection*>(
               &_A_Indirection_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    185;

  friend void swap(A_Indirection& a, A_Indirection& b) {
    a.Swap(&b);
  }
  inline void Swap(A_Indirection* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(A_Indirection* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline A_Indirection* New() const final {
    return CreateMaybeMessage<A_Indirection>(nullptr);
  }

  A_Indirection* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<A_Indirection>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const A_Indirection& from);
  void MergeFrom(const A_Indirection& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(A_Indirection* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.A_Indirection";
  }
  protected:
  explicit A_Indirection(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIndirectionFieldNumber = 2,
    kArgFieldNumber = 1,
  };
  // repeated .pg_query.Node indirection = 2 [json_name = "indirection"];
  int indirection_size() const;
  private:
  int _internal_indirection_size() const;
  public:
  void clear_indirection();
  ::pg_query::Node* mutable_indirection(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_indirection();
  private:
  const ::pg_query::Node& _internal_indirection(int index) const;
  ::pg_query::Node* _internal_add_indirection();
  public:
  const ::pg_query::Node& indirection(int index) const;
  ::pg_query::Node* add_indirection();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      indirection() const;

  // .pg_query.Node arg = 1 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // @@protoc_insertion_point(class_scope:pg_query.A_Indirection)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > indirection_;
  ::pg_query::Node* arg_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class A_ArrayExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.A_ArrayExpr) */ {
 public:
  inline A_ArrayExpr() : A_ArrayExpr(nullptr) {}
  virtual ~A_ArrayExpr();

  A_ArrayExpr(const A_ArrayExpr& from);
  A_ArrayExpr(A_ArrayExpr&& from) noexcept
    : A_ArrayExpr() {
    *this = ::std::move(from);
  }

  inline A_ArrayExpr& operator=(const A_ArrayExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline A_ArrayExpr& operator=(A_ArrayExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const A_ArrayExpr& default_instance();

  static inline const A_ArrayExpr* internal_default_instance() {
    return reinterpret_cast<const A_ArrayExpr*>(
               &_A_ArrayExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    186;

  friend void swap(A_ArrayExpr& a, A_ArrayExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(A_ArrayExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(A_ArrayExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline A_ArrayExpr* New() const final {
    return CreateMaybeMessage<A_ArrayExpr>(nullptr);
  }

  A_ArrayExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<A_ArrayExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const A_ArrayExpr& from);
  void MergeFrom(const A_ArrayExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(A_ArrayExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.A_ArrayExpr";
  }
  protected:
  explicit A_ArrayExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kElementsFieldNumber = 1,
    kLocationFieldNumber = 2,
  };
  // repeated .pg_query.Node elements = 1 [json_name = "elements"];
  int elements_size() const;
  private:
  int _internal_elements_size() const;
  public:
  void clear_elements();
  ::pg_query::Node* mutable_elements(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_elements();
  private:
  const ::pg_query::Node& _internal_elements(int index) const;
  ::pg_query::Node* _internal_add_elements();
  public:
  const ::pg_query::Node& elements(int index) const;
  ::pg_query::Node* add_elements();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      elements() const;

  // int32 location = 2 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.A_ArrayExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > elements_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ResTarget PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ResTarget) */ {
 public:
  inline ResTarget() : ResTarget(nullptr) {}
  virtual ~ResTarget();

  ResTarget(const ResTarget& from);
  ResTarget(ResTarget&& from) noexcept
    : ResTarget() {
    *this = ::std::move(from);
  }

  inline ResTarget& operator=(const ResTarget& from) {
    CopyFrom(from);
    return *this;
  }
  inline ResTarget& operator=(ResTarget&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ResTarget& default_instance();

  static inline const ResTarget* internal_default_instance() {
    return reinterpret_cast<const ResTarget*>(
               &_ResTarget_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    187;

  friend void swap(ResTarget& a, ResTarget& b) {
    a.Swap(&b);
  }
  inline void Swap(ResTarget* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ResTarget* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ResTarget* New() const final {
    return CreateMaybeMessage<ResTarget>(nullptr);
  }

  ResTarget* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ResTarget>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ResTarget& from);
  void MergeFrom(const ResTarget& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ResTarget* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ResTarget";
  }
  protected:
  explicit ResTarget(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIndirectionFieldNumber = 2,
    kNameFieldNumber = 1,
    kValFieldNumber = 3,
    kLocationFieldNumber = 4,
  };
  // repeated .pg_query.Node indirection = 2 [json_name = "indirection"];
  int indirection_size() const;
  private:
  int _internal_indirection_size() const;
  public:
  void clear_indirection();
  ::pg_query::Node* mutable_indirection(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_indirection();
  private:
  const ::pg_query::Node& _internal_indirection(int index) const;
  ::pg_query::Node* _internal_add_indirection();
  public:
  const ::pg_query::Node& indirection(int index) const;
  ::pg_query::Node* add_indirection();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      indirection() const;

  // string name = 1 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .pg_query.Node val = 3 [json_name = "val"];
  bool has_val() const;
  private:
  bool _internal_has_val() const;
  public:
  void clear_val();
  const ::pg_query::Node& val() const;
  ::pg_query::Node* release_val();
  ::pg_query::Node* mutable_val();
  void set_allocated_val(::pg_query::Node* val);
  private:
  const ::pg_query::Node& _internal_val() const;
  ::pg_query::Node* _internal_mutable_val();
  public:
  void unsafe_arena_set_allocated_val(
      ::pg_query::Node* val);
  ::pg_query::Node* unsafe_arena_release_val();

  // int32 location = 4 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ResTarget)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > indirection_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::pg_query::Node* val_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class MultiAssignRef PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.MultiAssignRef) */ {
 public:
  inline MultiAssignRef() : MultiAssignRef(nullptr) {}
  virtual ~MultiAssignRef();

  MultiAssignRef(const MultiAssignRef& from);
  MultiAssignRef(MultiAssignRef&& from) noexcept
    : MultiAssignRef() {
    *this = ::std::move(from);
  }

  inline MultiAssignRef& operator=(const MultiAssignRef& from) {
    CopyFrom(from);
    return *this;
  }
  inline MultiAssignRef& operator=(MultiAssignRef&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MultiAssignRef& default_instance();

  static inline const MultiAssignRef* internal_default_instance() {
    return reinterpret_cast<const MultiAssignRef*>(
               &_MultiAssignRef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    188;

  friend void swap(MultiAssignRef& a, MultiAssignRef& b) {
    a.Swap(&b);
  }
  inline void Swap(MultiAssignRef* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MultiAssignRef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MultiAssignRef* New() const final {
    return CreateMaybeMessage<MultiAssignRef>(nullptr);
  }

  MultiAssignRef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MultiAssignRef>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MultiAssignRef& from);
  void MergeFrom(const MultiAssignRef& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MultiAssignRef* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.MultiAssignRef";
  }
  protected:
  explicit MultiAssignRef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSourceFieldNumber = 1,
    kColnoFieldNumber = 2,
    kNcolumnsFieldNumber = 3,
  };
  // .pg_query.Node source = 1 [json_name = "source"];
  bool has_source() const;
  private:
  bool _internal_has_source() const;
  public:
  void clear_source();
  const ::pg_query::Node& source() const;
  ::pg_query::Node* release_source();
  ::pg_query::Node* mutable_source();
  void set_allocated_source(::pg_query::Node* source);
  private:
  const ::pg_query::Node& _internal_source() const;
  ::pg_query::Node* _internal_mutable_source();
  public:
  void unsafe_arena_set_allocated_source(
      ::pg_query::Node* source);
  ::pg_query::Node* unsafe_arena_release_source();

  // int32 colno = 2 [json_name = "colno"];
  void clear_colno();
  ::PROTOBUF_NAMESPACE_ID::int32 colno() const;
  void set_colno(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_colno() const;
  void _internal_set_colno(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 ncolumns = 3 [json_name = "ncolumns"];
  void clear_ncolumns();
  ::PROTOBUF_NAMESPACE_ID::int32 ncolumns() const;
  void set_ncolumns(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_ncolumns() const;
  void _internal_set_ncolumns(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.MultiAssignRef)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* source_;
  ::PROTOBUF_NAMESPACE_ID::int32 colno_;
  ::PROTOBUF_NAMESPACE_ID::int32 ncolumns_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class TypeCast PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TypeCast) */ {
 public:
  inline TypeCast() : TypeCast(nullptr) {}
  virtual ~TypeCast();

  TypeCast(const TypeCast& from);
  TypeCast(TypeCast&& from) noexcept
    : TypeCast() {
    *this = ::std::move(from);
  }

  inline TypeCast& operator=(const TypeCast& from) {
    CopyFrom(from);
    return *this;
  }
  inline TypeCast& operator=(TypeCast&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TypeCast& default_instance();

  static inline const TypeCast* internal_default_instance() {
    return reinterpret_cast<const TypeCast*>(
               &_TypeCast_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    189;

  friend void swap(TypeCast& a, TypeCast& b) {
    a.Swap(&b);
  }
  inline void Swap(TypeCast* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TypeCast* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TypeCast* New() const final {
    return CreateMaybeMessage<TypeCast>(nullptr);
  }

  TypeCast* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TypeCast>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TypeCast& from);
  void MergeFrom(const TypeCast& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TypeCast* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.TypeCast";
  }
  protected:
  explicit TypeCast(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kArgFieldNumber = 1,
    kTypeNameFieldNumber = 2,
    kLocationFieldNumber = 3,
  };
  // .pg_query.Node arg = 1 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // .pg_query.TypeName type_name = 2 [json_name = "typeName"];
  bool has_type_name() const;
  private:
  bool _internal_has_type_name() const;
  public:
  void clear_type_name();
  const ::pg_query::TypeName& type_name() const;
  ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* type_name);
  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();
  public:
  void unsafe_arena_set_allocated_type_name(
      ::pg_query::TypeName* type_name);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  // int32 location = 3 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.TypeCast)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* arg_;
  ::pg_query::TypeName* type_name_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CollateClause PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CollateClause) */ {
 public:
  inline CollateClause() : CollateClause(nullptr) {}
  virtual ~CollateClause();

  CollateClause(const CollateClause& from);
  CollateClause(CollateClause&& from) noexcept
    : CollateClause() {
    *this = ::std::move(from);
  }

  inline CollateClause& operator=(const CollateClause& from) {
    CopyFrom(from);
    return *this;
  }
  inline CollateClause& operator=(CollateClause&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CollateClause& default_instance();

  static inline const CollateClause* internal_default_instance() {
    return reinterpret_cast<const CollateClause*>(
               &_CollateClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    190;

  friend void swap(CollateClause& a, CollateClause& b) {
    a.Swap(&b);
  }
  inline void Swap(CollateClause* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CollateClause* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CollateClause* New() const final {
    return CreateMaybeMessage<CollateClause>(nullptr);
  }

  CollateClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CollateClause>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CollateClause& from);
  void MergeFrom(const CollateClause& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CollateClause* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CollateClause";
  }
  protected:
  explicit CollateClause(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCollnameFieldNumber = 2,
    kArgFieldNumber = 1,
    kLocationFieldNumber = 3,
  };
  // repeated .pg_query.Node collname = 2 [json_name = "collname"];
  int collname_size() const;
  private:
  int _internal_collname_size() const;
  public:
  void clear_collname();
  ::pg_query::Node* mutable_collname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_collname();
  private:
  const ::pg_query::Node& _internal_collname(int index) const;
  ::pg_query::Node* _internal_add_collname();
  public:
  const ::pg_query::Node& collname(int index) const;
  ::pg_query::Node* add_collname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      collname() const;

  // .pg_query.Node arg = 1 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // int32 location = 3 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CollateClause)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > collname_;
  ::pg_query::Node* arg_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class SortBy PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SortBy) */ {
 public:
  inline SortBy() : SortBy(nullptr) {}
  virtual ~SortBy();

  SortBy(const SortBy& from);
  SortBy(SortBy&& from) noexcept
    : SortBy() {
    *this = ::std::move(from);
  }

  inline SortBy& operator=(const SortBy& from) {
    CopyFrom(from);
    return *this;
  }
  inline SortBy& operator=(SortBy&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SortBy& default_instance();

  static inline const SortBy* internal_default_instance() {
    return reinterpret_cast<const SortBy*>(
               &_SortBy_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    191;

  friend void swap(SortBy& a, SortBy& b) {
    a.Swap(&b);
  }
  inline void Swap(SortBy* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SortBy* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline SortBy* New() const final {
    return CreateMaybeMessage<SortBy>(nullptr);
  }

  SortBy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SortBy>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SortBy& from);
  void MergeFrom(const SortBy& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SortBy* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.SortBy";
  }
  protected:
  explicit SortBy(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kUseOpFieldNumber = 4,
    kNodeFieldNumber = 1,
    kSortbyDirFieldNumber = 2,
    kSortbyNullsFieldNumber = 3,
    kLocationFieldNumber = 5,
  };
  // repeated .pg_query.Node use_op = 4 [json_name = "useOp"];
  int use_op_size() const;
  private:
  int _internal_use_op_size() const;
  public:
  void clear_use_op();
  ::pg_query::Node* mutable_use_op(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_use_op();
  private:
  const ::pg_query::Node& _internal_use_op(int index) const;
  ::pg_query::Node* _internal_add_use_op();
  public:
  const ::pg_query::Node& use_op(int index) const;
  ::pg_query::Node* add_use_op();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      use_op() const;

  // .pg_query.Node node = 1 [json_name = "node"];
  bool has_node() const;
  private:
  bool _internal_has_node() const;
  public:
  void clear_node();
  const ::pg_query::Node& node() const;
  ::pg_query::Node* release_node();
  ::pg_query::Node* mutable_node();
  void set_allocated_node(::pg_query::Node* node);
  private:
  const ::pg_query::Node& _internal_node() const;
  ::pg_query::Node* _internal_mutable_node();
  public:
  void unsafe_arena_set_allocated_node(
      ::pg_query::Node* node);
  ::pg_query::Node* unsafe_arena_release_node();

  // .pg_query.SortByDir sortby_dir = 2 [json_name = "sortby_dir"];
  void clear_sortby_dir();
  ::pg_query::SortByDir sortby_dir() const;
  void set_sortby_dir(::pg_query::SortByDir value);
  private:
  ::pg_query::SortByDir _internal_sortby_dir() const;
  void _internal_set_sortby_dir(::pg_query::SortByDir value);
  public:

  // .pg_query.SortByNulls sortby_nulls = 3 [json_name = "sortby_nulls"];
  void clear_sortby_nulls();
  ::pg_query::SortByNulls sortby_nulls() const;
  void set_sortby_nulls(::pg_query::SortByNulls value);
  private:
  ::pg_query::SortByNulls _internal_sortby_nulls() const;
  void _internal_set_sortby_nulls(::pg_query::SortByNulls value);
  public:

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.SortBy)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > use_op_;
  ::pg_query::Node* node_;
  int sortby_dir_;
  int sortby_nulls_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class WindowDef PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.WindowDef) */ {
 public:
  inline WindowDef() : WindowDef(nullptr) {}
  virtual ~WindowDef();

  WindowDef(const WindowDef& from);
  WindowDef(WindowDef&& from) noexcept
    : WindowDef() {
    *this = ::std::move(from);
  }

  inline WindowDef& operator=(const WindowDef& from) {
    CopyFrom(from);
    return *this;
  }
  inline WindowDef& operator=(WindowDef&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const WindowDef& default_instance();

  static inline const WindowDef* internal_default_instance() {
    return reinterpret_cast<const WindowDef*>(
               &_WindowDef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    192;

  friend void swap(WindowDef& a, WindowDef& b) {
    a.Swap(&b);
  }
  inline void Swap(WindowDef* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(WindowDef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline WindowDef* New() const final {
    return CreateMaybeMessage<WindowDef>(nullptr);
  }

  WindowDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WindowDef>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WindowDef& from);
  void MergeFrom(const WindowDef& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WindowDef* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.WindowDef";
  }
  protected:
  explicit WindowDef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPartitionClauseFieldNumber = 3,
    kOrderClauseFieldNumber = 4,
    kNameFieldNumber = 1,
    kRefnameFieldNumber = 2,
    kStartOffsetFieldNumber = 6,
    kEndOffsetFieldNumber = 7,
    kFrameOptionsFieldNumber = 5,
    kLocationFieldNumber = 8,
  };
  // repeated .pg_query.Node partition_clause = 3 [json_name = "partitionClause"];
  int partition_clause_size() const;
  private:
  int _internal_partition_clause_size() const;
  public:
  void clear_partition_clause();
  ::pg_query::Node* mutable_partition_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_partition_clause();
  private:
  const ::pg_query::Node& _internal_partition_clause(int index) const;
  ::pg_query::Node* _internal_add_partition_clause();
  public:
  const ::pg_query::Node& partition_clause(int index) const;
  ::pg_query::Node* add_partition_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      partition_clause() const;

  // repeated .pg_query.Node order_clause = 4 [json_name = "orderClause"];
  int order_clause_size() const;
  private:
  int _internal_order_clause_size() const;
  public:
  void clear_order_clause();
  ::pg_query::Node* mutable_order_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_order_clause();
  private:
  const ::pg_query::Node& _internal_order_clause(int index) const;
  ::pg_query::Node* _internal_add_order_clause();
  public:
  const ::pg_query::Node& order_clause(int index) const;
  ::pg_query::Node* add_order_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      order_clause() const;

  // string name = 1 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string refname = 2 [json_name = "refname"];
  void clear_refname();
  const std::string& refname() const;
  void set_refname(const std::string& value);
  void set_refname(std::string&& value);
  void set_refname(const char* value);
  void set_refname(const char* value, size_t size);
  std::string* mutable_refname();
  std::string* release_refname();
  void set_allocated_refname(std::string* refname);
  private:
  const std::string& _internal_refname() const;
  void _internal_set_refname(const std::string& value);
  std::string* _internal_mutable_refname();
  public:

  // .pg_query.Node start_offset = 6 [json_name = "startOffset"];
  bool has_start_offset() const;
  private:
  bool _internal_has_start_offset() const;
  public:
  void clear_start_offset();
  const ::pg_query::Node& start_offset() const;
  ::pg_query::Node* release_start_offset();
  ::pg_query::Node* mutable_start_offset();
  void set_allocated_start_offset(::pg_query::Node* start_offset);
  private:
  const ::pg_query::Node& _internal_start_offset() const;
  ::pg_query::Node* _internal_mutable_start_offset();
  public:
  void unsafe_arena_set_allocated_start_offset(
      ::pg_query::Node* start_offset);
  ::pg_query::Node* unsafe_arena_release_start_offset();

  // .pg_query.Node end_offset = 7 [json_name = "endOffset"];
  bool has_end_offset() const;
  private:
  bool _internal_has_end_offset() const;
  public:
  void clear_end_offset();
  const ::pg_query::Node& end_offset() const;
  ::pg_query::Node* release_end_offset();
  ::pg_query::Node* mutable_end_offset();
  void set_allocated_end_offset(::pg_query::Node* end_offset);
  private:
  const ::pg_query::Node& _internal_end_offset() const;
  ::pg_query::Node* _internal_mutable_end_offset();
  public:
  void unsafe_arena_set_allocated_end_offset(
      ::pg_query::Node* end_offset);
  ::pg_query::Node* unsafe_arena_release_end_offset();

  // int32 frame_options = 5 [json_name = "frameOptions"];
  void clear_frame_options();
  ::PROTOBUF_NAMESPACE_ID::int32 frame_options() const;
  void set_frame_options(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_frame_options() const;
  void _internal_set_frame_options(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 location = 8 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.WindowDef)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > partition_clause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > order_clause_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr refname_;
  ::pg_query::Node* start_offset_;
  ::pg_query::Node* end_offset_;
  ::PROTOBUF_NAMESPACE_ID::int32 frame_options_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RangeSubselect PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeSubselect) */ {
 public:
  inline RangeSubselect() : RangeSubselect(nullptr) {}
  virtual ~RangeSubselect();

  RangeSubselect(const RangeSubselect& from);
  RangeSubselect(RangeSubselect&& from) noexcept
    : RangeSubselect() {
    *this = ::std::move(from);
  }

  inline RangeSubselect& operator=(const RangeSubselect& from) {
    CopyFrom(from);
    return *this;
  }
  inline RangeSubselect& operator=(RangeSubselect&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RangeSubselect& default_instance();

  static inline const RangeSubselect* internal_default_instance() {
    return reinterpret_cast<const RangeSubselect*>(
               &_RangeSubselect_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    193;

  friend void swap(RangeSubselect& a, RangeSubselect& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeSubselect* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeSubselect* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RangeSubselect* New() const final {
    return CreateMaybeMessage<RangeSubselect>(nullptr);
  }

  RangeSubselect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RangeSubselect>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RangeSubselect& from);
  void MergeFrom(const RangeSubselect& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RangeSubselect* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RangeSubselect";
  }
  protected:
  explicit RangeSubselect(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSubqueryFieldNumber = 2,
    kAliasFieldNumber = 3,
    kLateralFieldNumber = 1,
  };
  // .pg_query.Node subquery = 2 [json_name = "subquery"];
  bool has_subquery() const;
  private:
  bool _internal_has_subquery() const;
  public:
  void clear_subquery();
  const ::pg_query::Node& subquery() const;
  ::pg_query::Node* release_subquery();
  ::pg_query::Node* mutable_subquery();
  void set_allocated_subquery(::pg_query::Node* subquery);
  private:
  const ::pg_query::Node& _internal_subquery() const;
  ::pg_query::Node* _internal_mutable_subquery();
  public:
  void unsafe_arena_set_allocated_subquery(
      ::pg_query::Node* subquery);
  ::pg_query::Node* unsafe_arena_release_subquery();

  // .pg_query.Alias alias = 3 [json_name = "alias"];
  bool has_alias() const;
  private:
  bool _internal_has_alias() const;
  public:
  void clear_alias();
  const ::pg_query::Alias& alias() const;
  ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* alias);
  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();
  public:
  void unsafe_arena_set_allocated_alias(
      ::pg_query::Alias* alias);
  ::pg_query::Alias* unsafe_arena_release_alias();

  // bool lateral = 1 [json_name = "lateral"];
  void clear_lateral();
  bool lateral() const;
  void set_lateral(bool value);
  private:
  bool _internal_lateral() const;
  void _internal_set_lateral(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RangeSubselect)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* subquery_;
  ::pg_query::Alias* alias_;
  bool lateral_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RangeFunction PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeFunction) */ {
 public:
  inline RangeFunction() : RangeFunction(nullptr) {}
  virtual ~RangeFunction();

  RangeFunction(const RangeFunction& from);
  RangeFunction(RangeFunction&& from) noexcept
    : RangeFunction() {
    *this = ::std::move(from);
  }

  inline RangeFunction& operator=(const RangeFunction& from) {
    CopyFrom(from);
    return *this;
  }
  inline RangeFunction& operator=(RangeFunction&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RangeFunction& default_instance();

  static inline const RangeFunction* internal_default_instance() {
    return reinterpret_cast<const RangeFunction*>(
               &_RangeFunction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    194;

  friend void swap(RangeFunction& a, RangeFunction& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeFunction* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeFunction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RangeFunction* New() const final {
    return CreateMaybeMessage<RangeFunction>(nullptr);
  }

  RangeFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RangeFunction>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RangeFunction& from);
  void MergeFrom(const RangeFunction& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RangeFunction* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RangeFunction";
  }
  protected:
  explicit RangeFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFunctionsFieldNumber = 4,
    kColdeflistFieldNumber = 6,
    kAliasFieldNumber = 5,
    kLateralFieldNumber = 1,
    kOrdinalityFieldNumber = 2,
    kIsRowsfromFieldNumber = 3,
  };
  // repeated .pg_query.Node functions = 4 [json_name = "functions"];
  int functions_size() const;
  private:
  int _internal_functions_size() const;
  public:
  void clear_functions();
  ::pg_query::Node* mutable_functions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_functions();
  private:
  const ::pg_query::Node& _internal_functions(int index) const;
  ::pg_query::Node* _internal_add_functions();
  public:
  const ::pg_query::Node& functions(int index) const;
  ::pg_query::Node* add_functions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      functions() const;

  // repeated .pg_query.Node coldeflist = 6 [json_name = "coldeflist"];
  int coldeflist_size() const;
  private:
  int _internal_coldeflist_size() const;
  public:
  void clear_coldeflist();
  ::pg_query::Node* mutable_coldeflist(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_coldeflist();
  private:
  const ::pg_query::Node& _internal_coldeflist(int index) const;
  ::pg_query::Node* _internal_add_coldeflist();
  public:
  const ::pg_query::Node& coldeflist(int index) const;
  ::pg_query::Node* add_coldeflist();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      coldeflist() const;

  // .pg_query.Alias alias = 5 [json_name = "alias"];
  bool has_alias() const;
  private:
  bool _internal_has_alias() const;
  public:
  void clear_alias();
  const ::pg_query::Alias& alias() const;
  ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* alias);
  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();
  public:
  void unsafe_arena_set_allocated_alias(
      ::pg_query::Alias* alias);
  ::pg_query::Alias* unsafe_arena_release_alias();

  // bool lateral = 1 [json_name = "lateral"];
  void clear_lateral();
  bool lateral() const;
  void set_lateral(bool value);
  private:
  bool _internal_lateral() const;
  void _internal_set_lateral(bool value);
  public:

  // bool ordinality = 2 [json_name = "ordinality"];
  void clear_ordinality();
  bool ordinality() const;
  void set_ordinality(bool value);
  private:
  bool _internal_ordinality() const;
  void _internal_set_ordinality(bool value);
  public:

  // bool is_rowsfrom = 3 [json_name = "is_rowsfrom"];
  void clear_is_rowsfrom();
  bool is_rowsfrom() const;
  void set_is_rowsfrom(bool value);
  private:
  bool _internal_is_rowsfrom() const;
  void _internal_set_is_rowsfrom(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RangeFunction)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > functions_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coldeflist_;
  ::pg_query::Alias* alias_;
  bool lateral_;
  bool ordinality_;
  bool is_rowsfrom_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RangeTableSample PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTableSample) */ {
 public:
  inline RangeTableSample() : RangeTableSample(nullptr) {}
  virtual ~RangeTableSample();

  RangeTableSample(const RangeTableSample& from);
  RangeTableSample(RangeTableSample&& from) noexcept
    : RangeTableSample() {
    *this = ::std::move(from);
  }

  inline RangeTableSample& operator=(const RangeTableSample& from) {
    CopyFrom(from);
    return *this;
  }
  inline RangeTableSample& operator=(RangeTableSample&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RangeTableSample& default_instance();

  static inline const RangeTableSample* internal_default_instance() {
    return reinterpret_cast<const RangeTableSample*>(
               &_RangeTableSample_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    195;

  friend void swap(RangeTableSample& a, RangeTableSample& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeTableSample* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeTableSample* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RangeTableSample* New() const final {
    return CreateMaybeMessage<RangeTableSample>(nullptr);
  }

  RangeTableSample* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RangeTableSample>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RangeTableSample& from);
  void MergeFrom(const RangeTableSample& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RangeTableSample* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RangeTableSample";
  }
  protected:
  explicit RangeTableSample(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMethodFieldNumber = 2,
    kArgsFieldNumber = 3,
    kRelationFieldNumber = 1,
    kRepeatableFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // repeated .pg_query.Node method = 2 [json_name = "method"];
  int method_size() const;
  private:
  int _internal_method_size() const;
  public:
  void clear_method();
  ::pg_query::Node* mutable_method(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_method();
  private:
  const ::pg_query::Node& _internal_method(int index) const;
  ::pg_query::Node* _internal_add_method();
  public:
  const ::pg_query::Node& method(int index) const;
  ::pg_query::Node* add_method();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      method() const;

  // repeated .pg_query.Node args = 3 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // .pg_query.Node relation = 1 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::Node& relation() const;
  ::pg_query::Node* release_relation();
  ::pg_query::Node* mutable_relation();
  void set_allocated_relation(::pg_query::Node* relation);
  private:
  const ::pg_query::Node& _internal_relation() const;
  ::pg_query::Node* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::Node* relation);
  ::pg_query::Node* unsafe_arena_release_relation();

  // .pg_query.Node repeatable = 4 [json_name = "repeatable"];
  bool has_repeatable() const;
  private:
  bool _internal_has_repeatable() const;
  public:
  void clear_repeatable();
  const ::pg_query::Node& repeatable() const;
  ::pg_query::Node* release_repeatable();
  ::pg_query::Node* mutable_repeatable();
  void set_allocated_repeatable(::pg_query::Node* repeatable);
  private:
  const ::pg_query::Node& _internal_repeatable() const;
  ::pg_query::Node* _internal_mutable_repeatable();
  public:
  void unsafe_arena_set_allocated_repeatable(
      ::pg_query::Node* repeatable);
  ::pg_query::Node* unsafe_arena_release_repeatable();

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RangeTableSample)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > method_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::pg_query::Node* relation_;
  ::pg_query::Node* repeatable_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RangeTableFunc PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTableFunc) */ {
 public:
  inline RangeTableFunc() : RangeTableFunc(nullptr) {}
  virtual ~RangeTableFunc();

  RangeTableFunc(const RangeTableFunc& from);
  RangeTableFunc(RangeTableFunc&& from) noexcept
    : RangeTableFunc() {
    *this = ::std::move(from);
  }

  inline RangeTableFunc& operator=(const RangeTableFunc& from) {
    CopyFrom(from);
    return *this;
  }
  inline RangeTableFunc& operator=(RangeTableFunc&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RangeTableFunc& default_instance();

  static inline const RangeTableFunc* internal_default_instance() {
    return reinterpret_cast<const RangeTableFunc*>(
               &_RangeTableFunc_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    196;

  friend void swap(RangeTableFunc& a, RangeTableFunc& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeTableFunc* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeTableFunc* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RangeTableFunc* New() const final {
    return CreateMaybeMessage<RangeTableFunc>(nullptr);
  }

  RangeTableFunc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RangeTableFunc>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RangeTableFunc& from);
  void MergeFrom(const RangeTableFunc& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RangeTableFunc* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RangeTableFunc";
  }
  protected:
  explicit RangeTableFunc(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNamespacesFieldNumber = 4,
    kColumnsFieldNumber = 5,
    kDocexprFieldNumber = 2,
    kRowexprFieldNumber = 3,
    kAliasFieldNumber = 6,
    kLateralFieldNumber = 1,
    kLocationFieldNumber = 7,
  };
  // repeated .pg_query.Node namespaces = 4 [json_name = "namespaces"];
  int namespaces_size() const;
  private:
  int _internal_namespaces_size() const;
  public:
  void clear_namespaces();
  ::pg_query::Node* mutable_namespaces(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_namespaces();
  private:
  const ::pg_query::Node& _internal_namespaces(int index) const;
  ::pg_query::Node* _internal_add_namespaces();
  public:
  const ::pg_query::Node& namespaces(int index) const;
  ::pg_query::Node* add_namespaces();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      namespaces() const;

  // repeated .pg_query.Node columns = 5 [json_name = "columns"];
  int columns_size() const;
  private:
  int _internal_columns_size() const;
  public:
  void clear_columns();
  ::pg_query::Node* mutable_columns(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_columns();
  private:
  const ::pg_query::Node& _internal_columns(int index) const;
  ::pg_query::Node* _internal_add_columns();
  public:
  const ::pg_query::Node& columns(int index) const;
  ::pg_query::Node* add_columns();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      columns() const;

  // .pg_query.Node docexpr = 2 [json_name = "docexpr"];
  bool has_docexpr() const;
  private:
  bool _internal_has_docexpr() const;
  public:
  void clear_docexpr();
  const ::pg_query::Node& docexpr() const;
  ::pg_query::Node* release_docexpr();
  ::pg_query::Node* mutable_docexpr();
  void set_allocated_docexpr(::pg_query::Node* docexpr);
  private:
  const ::pg_query::Node& _internal_docexpr() const;
  ::pg_query::Node* _internal_mutable_docexpr();
  public:
  void unsafe_arena_set_allocated_docexpr(
      ::pg_query::Node* docexpr);
  ::pg_query::Node* unsafe_arena_release_docexpr();

  // .pg_query.Node rowexpr = 3 [json_name = "rowexpr"];
  bool has_rowexpr() const;
  private:
  bool _internal_has_rowexpr() const;
  public:
  void clear_rowexpr();
  const ::pg_query::Node& rowexpr() const;
  ::pg_query::Node* release_rowexpr();
  ::pg_query::Node* mutable_rowexpr();
  void set_allocated_rowexpr(::pg_query::Node* rowexpr);
  private:
  const ::pg_query::Node& _internal_rowexpr() const;
  ::pg_query::Node* _internal_mutable_rowexpr();
  public:
  void unsafe_arena_set_allocated_rowexpr(
      ::pg_query::Node* rowexpr);
  ::pg_query::Node* unsafe_arena_release_rowexpr();

  // .pg_query.Alias alias = 6 [json_name = "alias"];
  bool has_alias() const;
  private:
  bool _internal_has_alias() const;
  public:
  void clear_alias();
  const ::pg_query::Alias& alias() const;
  ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* alias);
  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();
  public:
  void unsafe_arena_set_allocated_alias(
      ::pg_query::Alias* alias);
  ::pg_query::Alias* unsafe_arena_release_alias();

  // bool lateral = 1 [json_name = "lateral"];
  void clear_lateral();
  bool lateral() const;
  void set_lateral(bool value);
  private:
  bool _internal_lateral() const;
  void _internal_set_lateral(bool value);
  public:

  // int32 location = 7 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RangeTableFunc)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > namespaces_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > columns_;
  ::pg_query::Node* docexpr_;
  ::pg_query::Node* rowexpr_;
  ::pg_query::Alias* alias_;
  bool lateral_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RangeTableFuncCol PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTableFuncCol) */ {
 public:
  inline RangeTableFuncCol() : RangeTableFuncCol(nullptr) {}
  virtual ~RangeTableFuncCol();

  RangeTableFuncCol(const RangeTableFuncCol& from);
  RangeTableFuncCol(RangeTableFuncCol&& from) noexcept
    : RangeTableFuncCol() {
    *this = ::std::move(from);
  }

  inline RangeTableFuncCol& operator=(const RangeTableFuncCol& from) {
    CopyFrom(from);
    return *this;
  }
  inline RangeTableFuncCol& operator=(RangeTableFuncCol&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RangeTableFuncCol& default_instance();

  static inline const RangeTableFuncCol* internal_default_instance() {
    return reinterpret_cast<const RangeTableFuncCol*>(
               &_RangeTableFuncCol_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    197;

  friend void swap(RangeTableFuncCol& a, RangeTableFuncCol& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeTableFuncCol* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeTableFuncCol* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RangeTableFuncCol* New() const final {
    return CreateMaybeMessage<RangeTableFuncCol>(nullptr);
  }

  RangeTableFuncCol* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RangeTableFuncCol>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RangeTableFuncCol& from);
  void MergeFrom(const RangeTableFuncCol& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RangeTableFuncCol* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RangeTableFuncCol";
  }
  protected:
  explicit RangeTableFuncCol(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kColnameFieldNumber = 1,
    kTypeNameFieldNumber = 2,
    kColexprFieldNumber = 5,
    kColdefexprFieldNumber = 6,
    kForOrdinalityFieldNumber = 3,
    kIsNotNullFieldNumber = 4,
    kLocationFieldNumber = 7,
  };
  // string colname = 1 [json_name = "colname"];
  void clear_colname();
  const std::string& colname() const;
  void set_colname(const std::string& value);
  void set_colname(std::string&& value);
  void set_colname(const char* value);
  void set_colname(const char* value, size_t size);
  std::string* mutable_colname();
  std::string* release_colname();
  void set_allocated_colname(std::string* colname);
  private:
  const std::string& _internal_colname() const;
  void _internal_set_colname(const std::string& value);
  std::string* _internal_mutable_colname();
  public:

  // .pg_query.TypeName type_name = 2 [json_name = "typeName"];
  bool has_type_name() const;
  private:
  bool _internal_has_type_name() const;
  public:
  void clear_type_name();
  const ::pg_query::TypeName& type_name() const;
  ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* type_name);
  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();
  public:
  void unsafe_arena_set_allocated_type_name(
      ::pg_query::TypeName* type_name);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  // .pg_query.Node colexpr = 5 [json_name = "colexpr"];
  bool has_colexpr() const;
  private:
  bool _internal_has_colexpr() const;
  public:
  void clear_colexpr();
  const ::pg_query::Node& colexpr() const;
  ::pg_query::Node* release_colexpr();
  ::pg_query::Node* mutable_colexpr();
  void set_allocated_colexpr(::pg_query::Node* colexpr);
  private:
  const ::pg_query::Node& _internal_colexpr() const;
  ::pg_query::Node* _internal_mutable_colexpr();
  public:
  void unsafe_arena_set_allocated_colexpr(
      ::pg_query::Node* colexpr);
  ::pg_query::Node* unsafe_arena_release_colexpr();

  // .pg_query.Node coldefexpr = 6 [json_name = "coldefexpr"];
  bool has_coldefexpr() const;
  private:
  bool _internal_has_coldefexpr() const;
  public:
  void clear_coldefexpr();
  const ::pg_query::Node& coldefexpr() const;
  ::pg_query::Node* release_coldefexpr();
  ::pg_query::Node* mutable_coldefexpr();
  void set_allocated_coldefexpr(::pg_query::Node* coldefexpr);
  private:
  const ::pg_query::Node& _internal_coldefexpr() const;
  ::pg_query::Node* _internal_mutable_coldefexpr();
  public:
  void unsafe_arena_set_allocated_coldefexpr(
      ::pg_query::Node* coldefexpr);
  ::pg_query::Node* unsafe_arena_release_coldefexpr();

  // bool for_ordinality = 3 [json_name = "for_ordinality"];
  void clear_for_ordinality();
  bool for_ordinality() const;
  void set_for_ordinality(bool value);
  private:
  bool _internal_for_ordinality() const;
  void _internal_set_for_ordinality(bool value);
  public:

  // bool is_not_null = 4 [json_name = "is_not_null"];
  void clear_is_not_null();
  bool is_not_null() const;
  void set_is_not_null(bool value);
  private:
  bool _internal_is_not_null() const;
  void _internal_set_is_not_null(bool value);
  public:

  // int32 location = 7 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RangeTableFuncCol)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr colname_;
  ::pg_query::TypeName* type_name_;
  ::pg_query::Node* colexpr_;
  ::pg_query::Node* coldefexpr_;
  bool for_ordinality_;
  bool is_not_null_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class TypeName PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TypeName) */ {
 public:
  inline TypeName() : TypeName(nullptr) {}
  virtual ~TypeName();

  TypeName(const TypeName& from);
  TypeName(TypeName&& from) noexcept
    : TypeName() {
    *this = ::std::move(from);
  }

  inline TypeName& operator=(const TypeName& from) {
    CopyFrom(from);
    return *this;
  }
  inline TypeName& operator=(TypeName&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TypeName& default_instance();

  static inline const TypeName* internal_default_instance() {
    return reinterpret_cast<const TypeName*>(
               &_TypeName_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    198;

  friend void swap(TypeName& a, TypeName& b) {
    a.Swap(&b);
  }
  inline void Swap(TypeName* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TypeName* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TypeName* New() const final {
    return CreateMaybeMessage<TypeName>(nullptr);
  }

  TypeName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TypeName>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TypeName& from);
  void MergeFrom(const TypeName& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TypeName* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.TypeName";
  }
  protected:
  explicit TypeName(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNamesFieldNumber = 1,
    kTypmodsFieldNumber = 5,
    kArrayBoundsFieldNumber = 7,
    kTypeOidFieldNumber = 2,
    kSetofFieldNumber = 3,
    kPctTypeFieldNumber = 4,
    kTypemodFieldNumber = 6,
    kLocationFieldNumber = 8,
  };
  // repeated .pg_query.Node names = 1 [json_name = "names"];
  int names_size() const;
  private:
  int _internal_names_size() const;
  public:
  void clear_names();
  ::pg_query::Node* mutable_names(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_names();
  private:
  const ::pg_query::Node& _internal_names(int index) const;
  ::pg_query::Node* _internal_add_names();
  public:
  const ::pg_query::Node& names(int index) const;
  ::pg_query::Node* add_names();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      names() const;

  // repeated .pg_query.Node typmods = 5 [json_name = "typmods"];
  int typmods_size() const;
  private:
  int _internal_typmods_size() const;
  public:
  void clear_typmods();
  ::pg_query::Node* mutable_typmods(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_typmods();
  private:
  const ::pg_query::Node& _internal_typmods(int index) const;
  ::pg_query::Node* _internal_add_typmods();
  public:
  const ::pg_query::Node& typmods(int index) const;
  ::pg_query::Node* add_typmods();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      typmods() const;

  // repeated .pg_query.Node array_bounds = 7 [json_name = "arrayBounds"];
  int array_bounds_size() const;
  private:
  int _internal_array_bounds_size() const;
  public:
  void clear_array_bounds();
  ::pg_query::Node* mutable_array_bounds(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_array_bounds();
  private:
  const ::pg_query::Node& _internal_array_bounds(int index) const;
  ::pg_query::Node* _internal_add_array_bounds();
  public:
  const ::pg_query::Node& array_bounds(int index) const;
  ::pg_query::Node* add_array_bounds();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      array_bounds() const;

  // uint32 type_oid = 2 [json_name = "typeOid"];
  void clear_type_oid();
  ::PROTOBUF_NAMESPACE_ID::uint32 type_oid() const;
  void set_type_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_oid() const;
  void _internal_set_type_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool setof = 3 [json_name = "setof"];
  void clear_setof();
  bool setof() const;
  void set_setof(bool value);
  private:
  bool _internal_setof() const;
  void _internal_set_setof(bool value);
  public:

  // bool pct_type = 4 [json_name = "pct_type"];
  void clear_pct_type();
  bool pct_type() const;
  void set_pct_type(bool value);
  private:
  bool _internal_pct_type() const;
  void _internal_set_pct_type(bool value);
  public:

  // int32 typemod = 6 [json_name = "typemod"];
  void clear_typemod();
  ::PROTOBUF_NAMESPACE_ID::int32 typemod() const;
  void set_typemod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_typemod() const;
  void _internal_set_typemod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 location = 8 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.TypeName)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > names_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > typmods_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > array_bounds_;
  ::PROTOBUF_NAMESPACE_ID::uint32 type_oid_;
  bool setof_;
  bool pct_type_;
  ::PROTOBUF_NAMESPACE_ID::int32 typemod_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ColumnDef PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ColumnDef) */ {
 public:
  inline ColumnDef() : ColumnDef(nullptr) {}
  virtual ~ColumnDef();

  ColumnDef(const ColumnDef& from);
  ColumnDef(ColumnDef&& from) noexcept
    : ColumnDef() {
    *this = ::std::move(from);
  }

  inline ColumnDef& operator=(const ColumnDef& from) {
    CopyFrom(from);
    return *this;
  }
  inline ColumnDef& operator=(ColumnDef&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ColumnDef& default_instance();

  static inline const ColumnDef* internal_default_instance() {
    return reinterpret_cast<const ColumnDef*>(
               &_ColumnDef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    199;

  friend void swap(ColumnDef& a, ColumnDef& b) {
    a.Swap(&b);
  }
  inline void Swap(ColumnDef* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ColumnDef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ColumnDef* New() const final {
    return CreateMaybeMessage<ColumnDef>(nullptr);
  }

  ColumnDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ColumnDef>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ColumnDef& from);
  void MergeFrom(const ColumnDef& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ColumnDef* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ColumnDef";
  }
  protected:
  explicit ColumnDef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kConstraintsFieldNumber = 15,
    kFdwoptionsFieldNumber = 16,
    kColnameFieldNumber = 1,
    kStorageFieldNumber = 7,
    kIdentityFieldNumber = 10,
    kGeneratedFieldNumber = 12,
    kTypeNameFieldNumber = 2,
    kRawDefaultFieldNumber = 8,
    kCookedDefaultFieldNumber = 9,
    kIdentitySequenceFieldNumber = 11,
    kCollClauseFieldNumber = 13,
    kInhcountFieldNumber = 3,
    kIsLocalFieldNumber = 4,
    kIsNotNullFieldNumber = 5,
    kIsFromTypeFieldNumber = 6,
    kCollOidFieldNumber = 14,
    kLocationFieldNumber = 17,
  };
  // repeated .pg_query.Node constraints = 15 [json_name = "constraints"];
  int constraints_size() const;
  private:
  int _internal_constraints_size() const;
  public:
  void clear_constraints();
  ::pg_query::Node* mutable_constraints(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_constraints();
  private:
  const ::pg_query::Node& _internal_constraints(int index) const;
  ::pg_query::Node* _internal_add_constraints();
  public:
  const ::pg_query::Node& constraints(int index) const;
  ::pg_query::Node* add_constraints();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      constraints() const;

  // repeated .pg_query.Node fdwoptions = 16 [json_name = "fdwoptions"];
  int fdwoptions_size() const;
  private:
  int _internal_fdwoptions_size() const;
  public:
  void clear_fdwoptions();
  ::pg_query::Node* mutable_fdwoptions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_fdwoptions();
  private:
  const ::pg_query::Node& _internal_fdwoptions(int index) const;
  ::pg_query::Node* _internal_add_fdwoptions();
  public:
  const ::pg_query::Node& fdwoptions(int index) const;
  ::pg_query::Node* add_fdwoptions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      fdwoptions() const;

  // string colname = 1 [json_name = "colname"];
  void clear_colname();
  const std::string& colname() const;
  void set_colname(const std::string& value);
  void set_colname(std::string&& value);
  void set_colname(const char* value);
  void set_colname(const char* value, size_t size);
  std::string* mutable_colname();
  std::string* release_colname();
  void set_allocated_colname(std::string* colname);
  private:
  const std::string& _internal_colname() const;
  void _internal_set_colname(const std::string& value);
  std::string* _internal_mutable_colname();
  public:

  // string storage = 7 [json_name = "storage"];
  void clear_storage();
  const std::string& storage() const;
  void set_storage(const std::string& value);
  void set_storage(std::string&& value);
  void set_storage(const char* value);
  void set_storage(const char* value, size_t size);
  std::string* mutable_storage();
  std::string* release_storage();
  void set_allocated_storage(std::string* storage);
  private:
  const std::string& _internal_storage() const;
  void _internal_set_storage(const std::string& value);
  std::string* _internal_mutable_storage();
  public:

  // string identity = 10 [json_name = "identity"];
  void clear_identity();
  const std::string& identity() const;
  void set_identity(const std::string& value);
  void set_identity(std::string&& value);
  void set_identity(const char* value);
  void set_identity(const char* value, size_t size);
  std::string* mutable_identity();
  std::string* release_identity();
  void set_allocated_identity(std::string* identity);
  private:
  const std::string& _internal_identity() const;
  void _internal_set_identity(const std::string& value);
  std::string* _internal_mutable_identity();
  public:

  // string generated = 12 [json_name = "generated"];
  void clear_generated();
  const std::string& generated() const;
  void set_generated(const std::string& value);
  void set_generated(std::string&& value);
  void set_generated(const char* value);
  void set_generated(const char* value, size_t size);
  std::string* mutable_generated();
  std::string* release_generated();
  void set_allocated_generated(std::string* generated);
  private:
  const std::string& _internal_generated() const;
  void _internal_set_generated(const std::string& value);
  std::string* _internal_mutable_generated();
  public:

  // .pg_query.TypeName type_name = 2 [json_name = "typeName"];
  bool has_type_name() const;
  private:
  bool _internal_has_type_name() const;
  public:
  void clear_type_name();
  const ::pg_query::TypeName& type_name() const;
  ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* type_name);
  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();
  public:
  void unsafe_arena_set_allocated_type_name(
      ::pg_query::TypeName* type_name);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  // .pg_query.Node raw_default = 8 [json_name = "raw_default"];
  bool has_raw_default() const;
  private:
  bool _internal_has_raw_default() const;
  public:
  void clear_raw_default();
  const ::pg_query::Node& raw_default() const;
  ::pg_query::Node* release_raw_default();
  ::pg_query::Node* mutable_raw_default();
  void set_allocated_raw_default(::pg_query::Node* raw_default);
  private:
  const ::pg_query::Node& _internal_raw_default() const;
  ::pg_query::Node* _internal_mutable_raw_default();
  public:
  void unsafe_arena_set_allocated_raw_default(
      ::pg_query::Node* raw_default);
  ::pg_query::Node* unsafe_arena_release_raw_default();

  // .pg_query.Node cooked_default = 9 [json_name = "cooked_default"];
  bool has_cooked_default() const;
  private:
  bool _internal_has_cooked_default() const;
  public:
  void clear_cooked_default();
  const ::pg_query::Node& cooked_default() const;
  ::pg_query::Node* release_cooked_default();
  ::pg_query::Node* mutable_cooked_default();
  void set_allocated_cooked_default(::pg_query::Node* cooked_default);
  private:
  const ::pg_query::Node& _internal_cooked_default() const;
  ::pg_query::Node* _internal_mutable_cooked_default();
  public:
  void unsafe_arena_set_allocated_cooked_default(
      ::pg_query::Node* cooked_default);
  ::pg_query::Node* unsafe_arena_release_cooked_default();

  // .pg_query.RangeVar identity_sequence = 11 [json_name = "identitySequence"];
  bool has_identity_sequence() const;
  private:
  bool _internal_has_identity_sequence() const;
  public:
  void clear_identity_sequence();
  const ::pg_query::RangeVar& identity_sequence() const;
  ::pg_query::RangeVar* release_identity_sequence();
  ::pg_query::RangeVar* mutable_identity_sequence();
  void set_allocated_identity_sequence(::pg_query::RangeVar* identity_sequence);
  private:
  const ::pg_query::RangeVar& _internal_identity_sequence() const;
  ::pg_query::RangeVar* _internal_mutable_identity_sequence();
  public:
  void unsafe_arena_set_allocated_identity_sequence(
      ::pg_query::RangeVar* identity_sequence);
  ::pg_query::RangeVar* unsafe_arena_release_identity_sequence();

  // .pg_query.CollateClause coll_clause = 13 [json_name = "collClause"];
  bool has_coll_clause() const;
  private:
  bool _internal_has_coll_clause() const;
  public:
  void clear_coll_clause();
  const ::pg_query::CollateClause& coll_clause() const;
  ::pg_query::CollateClause* release_coll_clause();
  ::pg_query::CollateClause* mutable_coll_clause();
  void set_allocated_coll_clause(::pg_query::CollateClause* coll_clause);
  private:
  const ::pg_query::CollateClause& _internal_coll_clause() const;
  ::pg_query::CollateClause* _internal_mutable_coll_clause();
  public:
  void unsafe_arena_set_allocated_coll_clause(
      ::pg_query::CollateClause* coll_clause);
  ::pg_query::CollateClause* unsafe_arena_release_coll_clause();

  // int32 inhcount = 3 [json_name = "inhcount"];
  void clear_inhcount();
  ::PROTOBUF_NAMESPACE_ID::int32 inhcount() const;
  void set_inhcount(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_inhcount() const;
  void _internal_set_inhcount(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool is_local = 4 [json_name = "is_local"];
  void clear_is_local();
  bool is_local() const;
  void set_is_local(bool value);
  private:
  bool _internal_is_local() const;
  void _internal_set_is_local(bool value);
  public:

  // bool is_not_null = 5 [json_name = "is_not_null"];
  void clear_is_not_null();
  bool is_not_null() const;
  void set_is_not_null(bool value);
  private:
  bool _internal_is_not_null() const;
  void _internal_set_is_not_null(bool value);
  public:

  // bool is_from_type = 6 [json_name = "is_from_type"];
  void clear_is_from_type();
  bool is_from_type() const;
  void set_is_from_type(bool value);
  private:
  bool _internal_is_from_type() const;
  void _internal_set_is_from_type(bool value);
  public:

  // uint32 coll_oid = 14 [json_name = "collOid"];
  void clear_coll_oid();
  ::PROTOBUF_NAMESPACE_ID::uint32 coll_oid() const;
  void set_coll_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_coll_oid() const;
  void _internal_set_coll_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 location = 17 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ColumnDef)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > constraints_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > fdwoptions_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr colname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr storage_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr identity_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr generated_;
  ::pg_query::TypeName* type_name_;
  ::pg_query::Node* raw_default_;
  ::pg_query::Node* cooked_default_;
  ::pg_query::RangeVar* identity_sequence_;
  ::pg_query::CollateClause* coll_clause_;
  ::PROTOBUF_NAMESPACE_ID::int32 inhcount_;
  bool is_local_;
  bool is_not_null_;
  bool is_from_type_;
  ::PROTOBUF_NAMESPACE_ID::uint32 coll_oid_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class IndexElem PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.IndexElem) */ {
 public:
  inline IndexElem() : IndexElem(nullptr) {}
  virtual ~IndexElem();

  IndexElem(const IndexElem& from);
  IndexElem(IndexElem&& from) noexcept
    : IndexElem() {
    *this = ::std::move(from);
  }

  inline IndexElem& operator=(const IndexElem& from) {
    CopyFrom(from);
    return *this;
  }
  inline IndexElem& operator=(IndexElem&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const IndexElem& default_instance();

  static inline const IndexElem* internal_default_instance() {
    return reinterpret_cast<const IndexElem*>(
               &_IndexElem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    200;

  friend void swap(IndexElem& a, IndexElem& b) {
    a.Swap(&b);
  }
  inline void Swap(IndexElem* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IndexElem* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline IndexElem* New() const final {
    return CreateMaybeMessage<IndexElem>(nullptr);
  }

  IndexElem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<IndexElem>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const IndexElem& from);
  void MergeFrom(const IndexElem& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(IndexElem* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.IndexElem";
  }
  protected:
  explicit IndexElem(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCollationFieldNumber = 4,
    kOpclassFieldNumber = 5,
    kOpclassoptsFieldNumber = 6,
    kNameFieldNumber = 1,
    kIndexcolnameFieldNumber = 3,
    kExprFieldNumber = 2,
    kOrderingFieldNumber = 7,
    kNullsOrderingFieldNumber = 8,
  };
  // repeated .pg_query.Node collation = 4 [json_name = "collation"];
  int collation_size() const;
  private:
  int _internal_collation_size() const;
  public:
  void clear_collation();
  ::pg_query::Node* mutable_collation(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_collation();
  private:
  const ::pg_query::Node& _internal_collation(int index) const;
  ::pg_query::Node* _internal_add_collation();
  public:
  const ::pg_query::Node& collation(int index) const;
  ::pg_query::Node* add_collation();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      collation() const;

  // repeated .pg_query.Node opclass = 5 [json_name = "opclass"];
  int opclass_size() const;
  private:
  int _internal_opclass_size() const;
  public:
  void clear_opclass();
  ::pg_query::Node* mutable_opclass(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_opclass();
  private:
  const ::pg_query::Node& _internal_opclass(int index) const;
  ::pg_query::Node* _internal_add_opclass();
  public:
  const ::pg_query::Node& opclass(int index) const;
  ::pg_query::Node* add_opclass();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      opclass() const;

  // repeated .pg_query.Node opclassopts = 6 [json_name = "opclassopts"];
  int opclassopts_size() const;
  private:
  int _internal_opclassopts_size() const;
  public:
  void clear_opclassopts();
  ::pg_query::Node* mutable_opclassopts(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_opclassopts();
  private:
  const ::pg_query::Node& _internal_opclassopts(int index) const;
  ::pg_query::Node* _internal_add_opclassopts();
  public:
  const ::pg_query::Node& opclassopts(int index) const;
  ::pg_query::Node* add_opclassopts();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      opclassopts() const;

  // string name = 1 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string indexcolname = 3 [json_name = "indexcolname"];
  void clear_indexcolname();
  const std::string& indexcolname() const;
  void set_indexcolname(const std::string& value);
  void set_indexcolname(std::string&& value);
  void set_indexcolname(const char* value);
  void set_indexcolname(const char* value, size_t size);
  std::string* mutable_indexcolname();
  std::string* release_indexcolname();
  void set_allocated_indexcolname(std::string* indexcolname);
  private:
  const std::string& _internal_indexcolname() const;
  void _internal_set_indexcolname(const std::string& value);
  std::string* _internal_mutable_indexcolname();
  public:

  // .pg_query.Node expr = 2 [json_name = "expr"];
  bool has_expr() const;
  private:
  bool _internal_has_expr() const;
  public:
  void clear_expr();
  const ::pg_query::Node& expr() const;
  ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* expr);
  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();
  public:
  void unsafe_arena_set_allocated_expr(
      ::pg_query::Node* expr);
  ::pg_query::Node* unsafe_arena_release_expr();

  // .pg_query.SortByDir ordering = 7 [json_name = "ordering"];
  void clear_ordering();
  ::pg_query::SortByDir ordering() const;
  void set_ordering(::pg_query::SortByDir value);
  private:
  ::pg_query::SortByDir _internal_ordering() const;
  void _internal_set_ordering(::pg_query::SortByDir value);
  public:

  // .pg_query.SortByNulls nulls_ordering = 8 [json_name = "nulls_ordering"];
  void clear_nulls_ordering();
  ::pg_query::SortByNulls nulls_ordering() const;
  void set_nulls_ordering(::pg_query::SortByNulls value);
  private:
  ::pg_query::SortByNulls _internal_nulls_ordering() const;
  void _internal_set_nulls_ordering(::pg_query::SortByNulls value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.IndexElem)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > collation_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opclass_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opclassopts_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr indexcolname_;
  ::pg_query::Node* expr_;
  int ordering_;
  int nulls_ordering_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class Constraint PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Constraint) */ {
 public:
  inline Constraint() : Constraint(nullptr) {}
  virtual ~Constraint();

  Constraint(const Constraint& from);
  Constraint(Constraint&& from) noexcept
    : Constraint() {
    *this = ::std::move(from);
  }

  inline Constraint& operator=(const Constraint& from) {
    CopyFrom(from);
    return *this;
  }
  inline Constraint& operator=(Constraint&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Constraint& default_instance();

  static inline const Constraint* internal_default_instance() {
    return reinterpret_cast<const Constraint*>(
               &_Constraint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    201;

  friend void swap(Constraint& a, Constraint& b) {
    a.Swap(&b);
  }
  inline void Swap(Constraint* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Constraint* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Constraint* New() const final {
    return CreateMaybeMessage<Constraint>(nullptr);
  }

  Constraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Constraint>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Constraint& from);
  void MergeFrom(const Constraint& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Constraint* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.Constraint";
  }
  protected:
  explicit Constraint(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeysFieldNumber = 10,
    kIncludingFieldNumber = 11,
    kExclusionsFieldNumber = 12,
    kOptionsFieldNumber = 13,
    kFkAttrsFieldNumber = 20,
    kPkAttrsFieldNumber = 21,
    kOldConpfeqopFieldNumber = 25,
    kConnameFieldNumber = 2,
    kCookedExprFieldNumber = 8,
    kGeneratedWhenFieldNumber = 9,
    kIndexnameFieldNumber = 14,
    kIndexspaceFieldNumber = 15,
    kAccessMethodFieldNumber = 17,
    kFkMatchtypeFieldNumber = 22,
    kFkUpdActionFieldNumber = 23,
    kFkDelActionFieldNumber = 24,
    kRawExprFieldNumber = 7,
    kWhereClauseFieldNumber = 18,
    kPktableFieldNumber = 19,
    kContypeFieldNumber = 1,
    kLocationFieldNumber = 5,
    kDeferrableFieldNumber = 3,
    kInitdeferredFieldNumber = 4,
    kIsNoInheritFieldNumber = 6,
    kResetDefaultTblspcFieldNumber = 16,
    kOldPktableOidFieldNumber = 26,
    kSkipValidationFieldNumber = 27,
    kInitiallyValidFieldNumber = 28,
  };
  // repeated .pg_query.Node keys = 10 [json_name = "keys"];
  int keys_size() const;
  private:
  int _internal_keys_size() const;
  public:
  void clear_keys();
  ::pg_query::Node* mutable_keys(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_keys();
  private:
  const ::pg_query::Node& _internal_keys(int index) const;
  ::pg_query::Node* _internal_add_keys();
  public:
  const ::pg_query::Node& keys(int index) const;
  ::pg_query::Node* add_keys();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      keys() const;

  // repeated .pg_query.Node including = 11 [json_name = "including"];
  int including_size() const;
  private:
  int _internal_including_size() const;
  public:
  void clear_including();
  ::pg_query::Node* mutable_including(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_including();
  private:
  const ::pg_query::Node& _internal_including(int index) const;
  ::pg_query::Node* _internal_add_including();
  public:
  const ::pg_query::Node& including(int index) const;
  ::pg_query::Node* add_including();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      including() const;

  // repeated .pg_query.Node exclusions = 12 [json_name = "exclusions"];
  int exclusions_size() const;
  private:
  int _internal_exclusions_size() const;
  public:
  void clear_exclusions();
  ::pg_query::Node* mutable_exclusions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_exclusions();
  private:
  const ::pg_query::Node& _internal_exclusions(int index) const;
  ::pg_query::Node* _internal_add_exclusions();
  public:
  const ::pg_query::Node& exclusions(int index) const;
  ::pg_query::Node* add_exclusions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      exclusions() const;

  // repeated .pg_query.Node options = 13 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::pg_query::Node* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::pg_query::Node& _internal_options(int index) const;
  ::pg_query::Node* _internal_add_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      options() const;

  // repeated .pg_query.Node fk_attrs = 20 [json_name = "fk_attrs"];
  int fk_attrs_size() const;
  private:
  int _internal_fk_attrs_size() const;
  public:
  void clear_fk_attrs();
  ::pg_query::Node* mutable_fk_attrs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_fk_attrs();
  private:
  const ::pg_query::Node& _internal_fk_attrs(int index) const;
  ::pg_query::Node* _internal_add_fk_attrs();
  public:
  const ::pg_query::Node& fk_attrs(int index) const;
  ::pg_query::Node* add_fk_attrs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      fk_attrs() const;

  // repeated .pg_query.Node pk_attrs = 21 [json_name = "pk_attrs"];
  int pk_attrs_size() const;
  private:
  int _internal_pk_attrs_size() const;
  public:
  void clear_pk_attrs();
  ::pg_query::Node* mutable_pk_attrs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_pk_attrs();
  private:
  const ::pg_query::Node& _internal_pk_attrs(int index) const;
  ::pg_query::Node* _internal_add_pk_attrs();
  public:
  const ::pg_query::Node& pk_attrs(int index) const;
  ::pg_query::Node* add_pk_attrs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      pk_attrs() const;

  // repeated .pg_query.Node old_conpfeqop = 25 [json_name = "old_conpfeqop"];
  int old_conpfeqop_size() const;
  private:
  int _internal_old_conpfeqop_size() const;
  public:
  void clear_old_conpfeqop();
  ::pg_query::Node* mutable_old_conpfeqop(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_old_conpfeqop();
  private:
  const ::pg_query::Node& _internal_old_conpfeqop(int index) const;
  ::pg_query::Node* _internal_add_old_conpfeqop();
  public:
  const ::pg_query::Node& old_conpfeqop(int index) const;
  ::pg_query::Node* add_old_conpfeqop();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      old_conpfeqop() const;

  // string conname = 2 [json_name = "conname"];
  void clear_conname();
  const std::string& conname() const;
  void set_conname(const std::string& value);
  void set_conname(std::string&& value);
  void set_conname(const char* value);
  void set_conname(const char* value, size_t size);
  std::string* mutable_conname();
  std::string* release_conname();
  void set_allocated_conname(std::string* conname);
  private:
  const std::string& _internal_conname() const;
  void _internal_set_conname(const std::string& value);
  std::string* _internal_mutable_conname();
  public:

  // string cooked_expr = 8 [json_name = "cooked_expr"];
  void clear_cooked_expr();
  const std::string& cooked_expr() const;
  void set_cooked_expr(const std::string& value);
  void set_cooked_expr(std::string&& value);
  void set_cooked_expr(const char* value);
  void set_cooked_expr(const char* value, size_t size);
  std::string* mutable_cooked_expr();
  std::string* release_cooked_expr();
  void set_allocated_cooked_expr(std::string* cooked_expr);
  private:
  const std::string& _internal_cooked_expr() const;
  void _internal_set_cooked_expr(const std::string& value);
  std::string* _internal_mutable_cooked_expr();
  public:

  // string generated_when = 9 [json_name = "generated_when"];
  void clear_generated_when();
  const std::string& generated_when() const;
  void set_generated_when(const std::string& value);
  void set_generated_when(std::string&& value);
  void set_generated_when(const char* value);
  void set_generated_when(const char* value, size_t size);
  std::string* mutable_generated_when();
  std::string* release_generated_when();
  void set_allocated_generated_when(std::string* generated_when);
  private:
  const std::string& _internal_generated_when() const;
  void _internal_set_generated_when(const std::string& value);
  std::string* _internal_mutable_generated_when();
  public:

  // string indexname = 14 [json_name = "indexname"];
  void clear_indexname();
  const std::string& indexname() const;
  void set_indexname(const std::string& value);
  void set_indexname(std::string&& value);
  void set_indexname(const char* value);
  void set_indexname(const char* value, size_t size);
  std::string* mutable_indexname();
  std::string* release_indexname();
  void set_allocated_indexname(std::string* indexname);
  private:
  const std::string& _internal_indexname() const;
  void _internal_set_indexname(const std::string& value);
  std::string* _internal_mutable_indexname();
  public:

  // string indexspace = 15 [json_name = "indexspace"];
  void clear_indexspace();
  const std::string& indexspace() const;
  void set_indexspace(const std::string& value);
  void set_indexspace(std::string&& value);
  void set_indexspace(const char* value);
  void set_indexspace(const char* value, size_t size);
  std::string* mutable_indexspace();
  std::string* release_indexspace();
  void set_allocated_indexspace(std::string* indexspace);
  private:
  const std::string& _internal_indexspace() const;
  void _internal_set_indexspace(const std::string& value);
  std::string* _internal_mutable_indexspace();
  public:

  // string access_method = 17 [json_name = "access_method"];
  void clear_access_method();
  const std::string& access_method() const;
  void set_access_method(const std::string& value);
  void set_access_method(std::string&& value);
  void set_access_method(const char* value);
  void set_access_method(const char* value, size_t size);
  std::string* mutable_access_method();
  std::string* release_access_method();
  void set_allocated_access_method(std::string* access_method);
  private:
  const std::string& _internal_access_method() const;
  void _internal_set_access_method(const std::string& value);
  std::string* _internal_mutable_access_method();
  public:

  // string fk_matchtype = 22 [json_name = "fk_matchtype"];
  void clear_fk_matchtype();
  const std::string& fk_matchtype() const;
  void set_fk_matchtype(const std::string& value);
  void set_fk_matchtype(std::string&& value);
  void set_fk_matchtype(const char* value);
  void set_fk_matchtype(const char* value, size_t size);
  std::string* mutable_fk_matchtype();
  std::string* release_fk_matchtype();
  void set_allocated_fk_matchtype(std::string* fk_matchtype);
  private:
  const std::string& _internal_fk_matchtype() const;
  void _internal_set_fk_matchtype(const std::string& value);
  std::string* _internal_mutable_fk_matchtype();
  public:

  // string fk_upd_action = 23 [json_name = "fk_upd_action"];
  void clear_fk_upd_action();
  const std::string& fk_upd_action() const;
  void set_fk_upd_action(const std::string& value);
  void set_fk_upd_action(std::string&& value);
  void set_fk_upd_action(const char* value);
  void set_fk_upd_action(const char* value, size_t size);
  std::string* mutable_fk_upd_action();
  std::string* release_fk_upd_action();
  void set_allocated_fk_upd_action(std::string* fk_upd_action);
  private:
  const std::string& _internal_fk_upd_action() const;
  void _internal_set_fk_upd_action(const std::string& value);
  std::string* _internal_mutable_fk_upd_action();
  public:

  // string fk_del_action = 24 [json_name = "fk_del_action"];
  void clear_fk_del_action();
  const std::string& fk_del_action() const;
  void set_fk_del_action(const std::string& value);
  void set_fk_del_action(std::string&& value);
  void set_fk_del_action(const char* value);
  void set_fk_del_action(const char* value, size_t size);
  std::string* mutable_fk_del_action();
  std::string* release_fk_del_action();
  void set_allocated_fk_del_action(std::string* fk_del_action);
  private:
  const std::string& _internal_fk_del_action() const;
  void _internal_set_fk_del_action(const std::string& value);
  std::string* _internal_mutable_fk_del_action();
  public:

  // .pg_query.Node raw_expr = 7 [json_name = "raw_expr"];
  bool has_raw_expr() const;
  private:
  bool _internal_has_raw_expr() const;
  public:
  void clear_raw_expr();
  const ::pg_query::Node& raw_expr() const;
  ::pg_query::Node* release_raw_expr();
  ::pg_query::Node* mutable_raw_expr();
  void set_allocated_raw_expr(::pg_query::Node* raw_expr);
  private:
  const ::pg_query::Node& _internal_raw_expr() const;
  ::pg_query::Node* _internal_mutable_raw_expr();
  public:
  void unsafe_arena_set_allocated_raw_expr(
      ::pg_query::Node* raw_expr);
  ::pg_query::Node* unsafe_arena_release_raw_expr();

  // .pg_query.Node where_clause = 18 [json_name = "where_clause"];
  bool has_where_clause() const;
  private:
  bool _internal_has_where_clause() const;
  public:
  void clear_where_clause();
  const ::pg_query::Node& where_clause() const;
  ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* where_clause);
  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();
  public:
  void unsafe_arena_set_allocated_where_clause(
      ::pg_query::Node* where_clause);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  // .pg_query.RangeVar pktable = 19 [json_name = "pktable"];
  bool has_pktable() const;
  private:
  bool _internal_has_pktable() const;
  public:
  void clear_pktable();
  const ::pg_query::RangeVar& pktable() const;
  ::pg_query::RangeVar* release_pktable();
  ::pg_query::RangeVar* mutable_pktable();
  void set_allocated_pktable(::pg_query::RangeVar* pktable);
  private:
  const ::pg_query::RangeVar& _internal_pktable() const;
  ::pg_query::RangeVar* _internal_mutable_pktable();
  public:
  void unsafe_arena_set_allocated_pktable(
      ::pg_query::RangeVar* pktable);
  ::pg_query::RangeVar* unsafe_arena_release_pktable();

  // .pg_query.ConstrType contype = 1 [json_name = "contype"];
  void clear_contype();
  ::pg_query::ConstrType contype() const;
  void set_contype(::pg_query::ConstrType value);
  private:
  ::pg_query::ConstrType _internal_contype() const;
  void _internal_set_contype(::pg_query::ConstrType value);
  public:

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool deferrable = 3 [json_name = "deferrable"];
  void clear_deferrable();
  bool deferrable() const;
  void set_deferrable(bool value);
  private:
  bool _internal_deferrable() const;
  void _internal_set_deferrable(bool value);
  public:

  // bool initdeferred = 4 [json_name = "initdeferred"];
  void clear_initdeferred();
  bool initdeferred() const;
  void set_initdeferred(bool value);
  private:
  bool _internal_initdeferred() const;
  void _internal_set_initdeferred(bool value);
  public:

  // bool is_no_inherit = 6 [json_name = "is_no_inherit"];
  void clear_is_no_inherit();
  bool is_no_inherit() const;
  void set_is_no_inherit(bool value);
  private:
  bool _internal_is_no_inherit() const;
  void _internal_set_is_no_inherit(bool value);
  public:

  // bool reset_default_tblspc = 16 [json_name = "reset_default_tblspc"];
  void clear_reset_default_tblspc();
  bool reset_default_tblspc() const;
  void set_reset_default_tblspc(bool value);
  private:
  bool _internal_reset_default_tblspc() const;
  void _internal_set_reset_default_tblspc(bool value);
  public:

  // uint32 old_pktable_oid = 26 [json_name = "old_pktable_oid"];
  void clear_old_pktable_oid();
  ::PROTOBUF_NAMESPACE_ID::uint32 old_pktable_oid() const;
  void set_old_pktable_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_old_pktable_oid() const;
  void _internal_set_old_pktable_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool skip_validation = 27 [json_name = "skip_validation"];
  void clear_skip_validation();
  bool skip_validation() const;
  void set_skip_validation(bool value);
  private:
  bool _internal_skip_validation() const;
  void _internal_set_skip_validation(bool value);
  public:

  // bool initially_valid = 28 [json_name = "initially_valid"];
  void clear_initially_valid();
  bool initially_valid() const;
  void set_initially_valid(bool value);
  private:
  bool _internal_initially_valid() const;
  void _internal_set_initially_valid(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.Constraint)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > keys_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > including_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > exclusions_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > fk_attrs_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > pk_attrs_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > old_conpfeqop_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cooked_expr_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr generated_when_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr indexname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr indexspace_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr access_method_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fk_matchtype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fk_upd_action_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fk_del_action_;
  ::pg_query::Node* raw_expr_;
  ::pg_query::Node* where_clause_;
  ::pg_query::RangeVar* pktable_;
  int contype_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  bool deferrable_;
  bool initdeferred_;
  bool is_no_inherit_;
  bool reset_default_tblspc_;
  ::PROTOBUF_NAMESPACE_ID::uint32 old_pktable_oid_;
  bool skip_validation_;
  bool initially_valid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class DefElem PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DefElem) */ {
 public:
  inline DefElem() : DefElem(nullptr) {}
  virtual ~DefElem();

  DefElem(const DefElem& from);
  DefElem(DefElem&& from) noexcept
    : DefElem() {
    *this = ::std::move(from);
  }

  inline DefElem& operator=(const DefElem& from) {
    CopyFrom(from);
    return *this;
  }
  inline DefElem& operator=(DefElem&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DefElem& default_instance();

  static inline const DefElem* internal_default_instance() {
    return reinterpret_cast<const DefElem*>(
               &_DefElem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    202;

  friend void swap(DefElem& a, DefElem& b) {
    a.Swap(&b);
  }
  inline void Swap(DefElem* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DefElem* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline DefElem* New() const final {
    return CreateMaybeMessage<DefElem>(nullptr);
  }

  DefElem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DefElem>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DefElem& from);
  void MergeFrom(const DefElem& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DefElem* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.DefElem";
  }
  protected:
  explicit DefElem(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDefnamespaceFieldNumber = 1,
    kDefnameFieldNumber = 2,
    kArgFieldNumber = 3,
    kDefactionFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // string defnamespace = 1 [json_name = "defnamespace"];
  void clear_defnamespace();
  const std::string& defnamespace() const;
  void set_defnamespace(const std::string& value);
  void set_defnamespace(std::string&& value);
  void set_defnamespace(const char* value);
  void set_defnamespace(const char* value, size_t size);
  std::string* mutable_defnamespace();
  std::string* release_defnamespace();
  void set_allocated_defnamespace(std::string* defnamespace);
  private:
  const std::string& _internal_defnamespace() const;
  void _internal_set_defnamespace(const std::string& value);
  std::string* _internal_mutable_defnamespace();
  public:

  // string defname = 2 [json_name = "defname"];
  void clear_defname();
  const std::string& defname() const;
  void set_defname(const std::string& value);
  void set_defname(std::string&& value);
  void set_defname(const char* value);
  void set_defname(const char* value, size_t size);
  std::string* mutable_defname();
  std::string* release_defname();
  void set_allocated_defname(std::string* defname);
  private:
  const std::string& _internal_defname() const;
  void _internal_set_defname(const std::string& value);
  std::string* _internal_mutable_defname();
  public:

  // .pg_query.Node arg = 3 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::pg_query::Node& arg() const;
  ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* arg);
  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::pg_query::Node* arg);
  ::pg_query::Node* unsafe_arena_release_arg();

  // .pg_query.DefElemAction defaction = 4 [json_name = "defaction"];
  void clear_defaction();
  ::pg_query::DefElemAction defaction() const;
  void set_defaction(::pg_query::DefElemAction value);
  private:
  ::pg_query::DefElemAction _internal_defaction() const;
  void _internal_set_defaction(::pg_query::DefElemAction value);
  public:

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.DefElem)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr defnamespace_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr defname_;
  ::pg_query::Node* arg_;
  int defaction_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RangeTblEntry PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTblEntry) */ {
 public:
  inline RangeTblEntry() : RangeTblEntry(nullptr) {}
  virtual ~RangeTblEntry();

  RangeTblEntry(const RangeTblEntry& from);
  RangeTblEntry(RangeTblEntry&& from) noexcept
    : RangeTblEntry() {
    *this = ::std::move(from);
  }

  inline RangeTblEntry& operator=(const RangeTblEntry& from) {
    CopyFrom(from);
    return *this;
  }
  inline RangeTblEntry& operator=(RangeTblEntry&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RangeTblEntry& default_instance();

  static inline const RangeTblEntry* internal_default_instance() {
    return reinterpret_cast<const RangeTblEntry*>(
               &_RangeTblEntry_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    203;

  friend void swap(RangeTblEntry& a, RangeTblEntry& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeTblEntry* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeTblEntry* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RangeTblEntry* New() const final {
    return CreateMaybeMessage<RangeTblEntry>(nullptr);
  }

  RangeTblEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RangeTblEntry>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RangeTblEntry& from);
  void MergeFrom(const RangeTblEntry& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RangeTblEntry* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RangeTblEntry";
  }
  protected:
  explicit RangeTblEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kJoinaliasvarsFieldNumber = 10,
    kJoinleftcolsFieldNumber = 11,
    kJoinrightcolsFieldNumber = 12,
    kFunctionsFieldNumber = 13,
    kValuesListsFieldNumber = 16,
    kColtypesFieldNumber = 20,
    kColtypmodsFieldNumber = 21,
    kColcollationsFieldNumber = 22,
    kSecurityQualsFieldNumber = 32,
    kRelkindFieldNumber = 3,
    kCtenameFieldNumber = 17,
    kEnrnameFieldNumber = 23,
    kTablesampleFieldNumber = 5,
    kSubqueryFieldNumber = 6,
    kTablefuncFieldNumber = 15,
    kAliasFieldNumber = 25,
    kErefFieldNumber = 26,
    kRtekindFieldNumber = 1,
    kRelidFieldNumber = 2,
    kRellockmodeFieldNumber = 4,
    kJointypeFieldNumber = 8,
    kJoinmergedcolsFieldNumber = 9,
    kSecurityBarrierFieldNumber = 7,
    kFuncordinalityFieldNumber = 14,
    kSelfReferenceFieldNumber = 19,
    kLateralFieldNumber = 27,
    kEnrtuplesFieldNumber = 24,
    kCtelevelsupFieldNumber = 18,
    kInhFieldNumber = 28,
    kInFromClFieldNumber = 29,
    kRequiredPermsFieldNumber = 30,
    kCheckAsUserFieldNumber = 31,
  };
  // repeated .pg_query.Node joinaliasvars = 10 [json_name = "joinaliasvars"];
  int joinaliasvars_size() const;
  private:
  int _internal_joinaliasvars_size() const;
  public:
  void clear_joinaliasvars();
  ::pg_query::Node* mutable_joinaliasvars(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_joinaliasvars();
  private:
  const ::pg_query::Node& _internal_joinaliasvars(int index) const;
  ::pg_query::Node* _internal_add_joinaliasvars();
  public:
  const ::pg_query::Node& joinaliasvars(int index) const;
  ::pg_query::Node* add_joinaliasvars();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      joinaliasvars() const;

  // repeated .pg_query.Node joinleftcols = 11 [json_name = "joinleftcols"];
  int joinleftcols_size() const;
  private:
  int _internal_joinleftcols_size() const;
  public:
  void clear_joinleftcols();
  ::pg_query::Node* mutable_joinleftcols(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_joinleftcols();
  private:
  const ::pg_query::Node& _internal_joinleftcols(int index) const;
  ::pg_query::Node* _internal_add_joinleftcols();
  public:
  const ::pg_query::Node& joinleftcols(int index) const;
  ::pg_query::Node* add_joinleftcols();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      joinleftcols() const;

  // repeated .pg_query.Node joinrightcols = 12 [json_name = "joinrightcols"];
  int joinrightcols_size() const;
  private:
  int _internal_joinrightcols_size() const;
  public:
  void clear_joinrightcols();
  ::pg_query::Node* mutable_joinrightcols(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_joinrightcols();
  private:
  const ::pg_query::Node& _internal_joinrightcols(int index) const;
  ::pg_query::Node* _internal_add_joinrightcols();
  public:
  const ::pg_query::Node& joinrightcols(int index) const;
  ::pg_query::Node* add_joinrightcols();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      joinrightcols() const;

  // repeated .pg_query.Node functions = 13 [json_name = "functions"];
  int functions_size() const;
  private:
  int _internal_functions_size() const;
  public:
  void clear_functions();
  ::pg_query::Node* mutable_functions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_functions();
  private:
  const ::pg_query::Node& _internal_functions(int index) const;
  ::pg_query::Node* _internal_add_functions();
  public:
  const ::pg_query::Node& functions(int index) const;
  ::pg_query::Node* add_functions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      functions() const;

  // repeated .pg_query.Node values_lists = 16 [json_name = "values_lists"];
  int values_lists_size() const;
  private:
  int _internal_values_lists_size() const;
  public:
  void clear_values_lists();
  ::pg_query::Node* mutable_values_lists(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_values_lists();
  private:
  const ::pg_query::Node& _internal_values_lists(int index) const;
  ::pg_query::Node* _internal_add_values_lists();
  public:
  const ::pg_query::Node& values_lists(int index) const;
  ::pg_query::Node* add_values_lists();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      values_lists() const;

  // repeated .pg_query.Node coltypes = 20 [json_name = "coltypes"];
  int coltypes_size() const;
  private:
  int _internal_coltypes_size() const;
  public:
  void clear_coltypes();
  ::pg_query::Node* mutable_coltypes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_coltypes();
  private:
  const ::pg_query::Node& _internal_coltypes(int index) const;
  ::pg_query::Node* _internal_add_coltypes();
  public:
  const ::pg_query::Node& coltypes(int index) const;
  ::pg_query::Node* add_coltypes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      coltypes() const;

  // repeated .pg_query.Node coltypmods = 21 [json_name = "coltypmods"];
  int coltypmods_size() const;
  private:
  int _internal_coltypmods_size() const;
  public:
  void clear_coltypmods();
  ::pg_query::Node* mutable_coltypmods(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_coltypmods();
  private:
  const ::pg_query::Node& _internal_coltypmods(int index) const;
  ::pg_query::Node* _internal_add_coltypmods();
  public:
  const ::pg_query::Node& coltypmods(int index) const;
  ::pg_query::Node* add_coltypmods();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      coltypmods() const;

  // repeated .pg_query.Node colcollations = 22 [json_name = "colcollations"];
  int colcollations_size() const;
  private:
  int _internal_colcollations_size() const;
  public:
  void clear_colcollations();
  ::pg_query::Node* mutable_colcollations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_colcollations();
  private:
  const ::pg_query::Node& _internal_colcollations(int index) const;
  ::pg_query::Node* _internal_add_colcollations();
  public:
  const ::pg_query::Node& colcollations(int index) const;
  ::pg_query::Node* add_colcollations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      colcollations() const;

  // repeated .pg_query.Node security_quals = 32 [json_name = "securityQuals"];
  int security_quals_size() const;
  private:
  int _internal_security_quals_size() const;
  public:
  void clear_security_quals();
  ::pg_query::Node* mutable_security_quals(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_security_quals();
  private:
  const ::pg_query::Node& _internal_security_quals(int index) const;
  ::pg_query::Node* _internal_add_security_quals();
  public:
  const ::pg_query::Node& security_quals(int index) const;
  ::pg_query::Node* add_security_quals();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      security_quals() const;

  // string relkind = 3 [json_name = "relkind"];
  void clear_relkind();
  const std::string& relkind() const;
  void set_relkind(const std::string& value);
  void set_relkind(std::string&& value);
  void set_relkind(const char* value);
  void set_relkind(const char* value, size_t size);
  std::string* mutable_relkind();
  std::string* release_relkind();
  void set_allocated_relkind(std::string* relkind);
  private:
  const std::string& _internal_relkind() const;
  void _internal_set_relkind(const std::string& value);
  std::string* _internal_mutable_relkind();
  public:

  // string ctename = 17 [json_name = "ctename"];
  void clear_ctename();
  const std::string& ctename() const;
  void set_ctename(const std::string& value);
  void set_ctename(std::string&& value);
  void set_ctename(const char* value);
  void set_ctename(const char* value, size_t size);
  std::string* mutable_ctename();
  std::string* release_ctename();
  void set_allocated_ctename(std::string* ctename);
  private:
  const std::string& _internal_ctename() const;
  void _internal_set_ctename(const std::string& value);
  std::string* _internal_mutable_ctename();
  public:

  // string enrname = 23 [json_name = "enrname"];
  void clear_enrname();
  const std::string& enrname() const;
  void set_enrname(const std::string& value);
  void set_enrname(std::string&& value);
  void set_enrname(const char* value);
  void set_enrname(const char* value, size_t size);
  std::string* mutable_enrname();
  std::string* release_enrname();
  void set_allocated_enrname(std::string* enrname);
  private:
  const std::string& _internal_enrname() const;
  void _internal_set_enrname(const std::string& value);
  std::string* _internal_mutable_enrname();
  public:

  // .pg_query.TableSampleClause tablesample = 5 [json_name = "tablesample"];
  bool has_tablesample() const;
  private:
  bool _internal_has_tablesample() const;
  public:
  void clear_tablesample();
  const ::pg_query::TableSampleClause& tablesample() const;
  ::pg_query::TableSampleClause* release_tablesample();
  ::pg_query::TableSampleClause* mutable_tablesample();
  void set_allocated_tablesample(::pg_query::TableSampleClause* tablesample);
  private:
  const ::pg_query::TableSampleClause& _internal_tablesample() const;
  ::pg_query::TableSampleClause* _internal_mutable_tablesample();
  public:
  void unsafe_arena_set_allocated_tablesample(
      ::pg_query::TableSampleClause* tablesample);
  ::pg_query::TableSampleClause* unsafe_arena_release_tablesample();

  // .pg_query.Query subquery = 6 [json_name = "subquery"];
  bool has_subquery() const;
  private:
  bool _internal_has_subquery() const;
  public:
  void clear_subquery();
  const ::pg_query::Query& subquery() const;
  ::pg_query::Query* release_subquery();
  ::pg_query::Query* mutable_subquery();
  void set_allocated_subquery(::pg_query::Query* subquery);
  private:
  const ::pg_query::Query& _internal_subquery() const;
  ::pg_query::Query* _internal_mutable_subquery();
  public:
  void unsafe_arena_set_allocated_subquery(
      ::pg_query::Query* subquery);
  ::pg_query::Query* unsafe_arena_release_subquery();

  // .pg_query.TableFunc tablefunc = 15 [json_name = "tablefunc"];
  bool has_tablefunc() const;
  private:
  bool _internal_has_tablefunc() const;
  public:
  void clear_tablefunc();
  const ::pg_query::TableFunc& tablefunc() const;
  ::pg_query::TableFunc* release_tablefunc();
  ::pg_query::TableFunc* mutable_tablefunc();
  void set_allocated_tablefunc(::pg_query::TableFunc* tablefunc);
  private:
  const ::pg_query::TableFunc& _internal_tablefunc() const;
  ::pg_query::TableFunc* _internal_mutable_tablefunc();
  public:
  void unsafe_arena_set_allocated_tablefunc(
      ::pg_query::TableFunc* tablefunc);
  ::pg_query::TableFunc* unsafe_arena_release_tablefunc();

  // .pg_query.Alias alias = 25 [json_name = "alias"];
  bool has_alias() const;
  private:
  bool _internal_has_alias() const;
  public:
  void clear_alias();
  const ::pg_query::Alias& alias() const;
  ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* alias);
  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();
  public:
  void unsafe_arena_set_allocated_alias(
      ::pg_query::Alias* alias);
  ::pg_query::Alias* unsafe_arena_release_alias();

  // .pg_query.Alias eref = 26 [json_name = "eref"];
  bool has_eref() const;
  private:
  bool _internal_has_eref() const;
  public:
  void clear_eref();
  const ::pg_query::Alias& eref() const;
  ::pg_query::Alias* release_eref();
  ::pg_query::Alias* mutable_eref();
  void set_allocated_eref(::pg_query::Alias* eref);
  private:
  const ::pg_query::Alias& _internal_eref() const;
  ::pg_query::Alias* _internal_mutable_eref();
  public:
  void unsafe_arena_set_allocated_eref(
      ::pg_query::Alias* eref);
  ::pg_query::Alias* unsafe_arena_release_eref();

  // .pg_query.RTEKind rtekind = 1 [json_name = "rtekind"];
  void clear_rtekind();
  ::pg_query::RTEKind rtekind() const;
  void set_rtekind(::pg_query::RTEKind value);
  private:
  ::pg_query::RTEKind _internal_rtekind() const;
  void _internal_set_rtekind(::pg_query::RTEKind value);
  public:

  // uint32 relid = 2 [json_name = "relid"];
  void clear_relid();
  ::PROTOBUF_NAMESPACE_ID::uint32 relid() const;
  void set_relid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_relid() const;
  void _internal_set_relid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 rellockmode = 4 [json_name = "rellockmode"];
  void clear_rellockmode();
  ::PROTOBUF_NAMESPACE_ID::int32 rellockmode() const;
  void set_rellockmode(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_rellockmode() const;
  void _internal_set_rellockmode(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // .pg_query.JoinType jointype = 8 [json_name = "jointype"];
  void clear_jointype();
  ::pg_query::JoinType jointype() const;
  void set_jointype(::pg_query::JoinType value);
  private:
  ::pg_query::JoinType _internal_jointype() const;
  void _internal_set_jointype(::pg_query::JoinType value);
  public:

  // int32 joinmergedcols = 9 [json_name = "joinmergedcols"];
  void clear_joinmergedcols();
  ::PROTOBUF_NAMESPACE_ID::int32 joinmergedcols() const;
  void set_joinmergedcols(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_joinmergedcols() const;
  void _internal_set_joinmergedcols(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool security_barrier = 7 [json_name = "security_barrier"];
  void clear_security_barrier();
  bool security_barrier() const;
  void set_security_barrier(bool value);
  private:
  bool _internal_security_barrier() const;
  void _internal_set_security_barrier(bool value);
  public:

  // bool funcordinality = 14 [json_name = "funcordinality"];
  void clear_funcordinality();
  bool funcordinality() const;
  void set_funcordinality(bool value);
  private:
  bool _internal_funcordinality() const;
  void _internal_set_funcordinality(bool value);
  public:

  // bool self_reference = 19 [json_name = "self_reference"];
  void clear_self_reference();
  bool self_reference() const;
  void set_self_reference(bool value);
  private:
  bool _internal_self_reference() const;
  void _internal_set_self_reference(bool value);
  public:

  // bool lateral = 27 [json_name = "lateral"];
  void clear_lateral();
  bool lateral() const;
  void set_lateral(bool value);
  private:
  bool _internal_lateral() const;
  void _internal_set_lateral(bool value);
  public:

  // double enrtuples = 24 [json_name = "enrtuples"];
  void clear_enrtuples();
  double enrtuples() const;
  void set_enrtuples(double value);
  private:
  double _internal_enrtuples() const;
  void _internal_set_enrtuples(double value);
  public:

  // uint32 ctelevelsup = 18 [json_name = "ctelevelsup"];
  void clear_ctelevelsup();
  ::PROTOBUF_NAMESPACE_ID::uint32 ctelevelsup() const;
  void set_ctelevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_ctelevelsup() const;
  void _internal_set_ctelevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool inh = 28 [json_name = "inh"];
  void clear_inh();
  bool inh() const;
  void set_inh(bool value);
  private:
  bool _internal_inh() const;
  void _internal_set_inh(bool value);
  public:

  // bool in_from_cl = 29 [json_name = "inFromCl"];
  void clear_in_from_cl();
  bool in_from_cl() const;
  void set_in_from_cl(bool value);
  private:
  bool _internal_in_from_cl() const;
  void _internal_set_in_from_cl(bool value);
  public:

  // uint32 required_perms = 30 [json_name = "requiredPerms"];
  void clear_required_perms();
  ::PROTOBUF_NAMESPACE_ID::uint32 required_perms() const;
  void set_required_perms(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_required_perms() const;
  void _internal_set_required_perms(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 check_as_user = 31 [json_name = "checkAsUser"];
  void clear_check_as_user();
  ::PROTOBUF_NAMESPACE_ID::uint32 check_as_user() const;
  void set_check_as_user(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_check_as_user() const;
  void _internal_set_check_as_user(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RangeTblEntry)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > joinaliasvars_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > joinleftcols_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > joinrightcols_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > functions_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > values_lists_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coltypes_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coltypmods_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > colcollations_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > security_quals_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr relkind_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ctename_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enrname_;
  ::pg_query::TableSampleClause* tablesample_;
  ::pg_query::Query* subquery_;
  ::pg_query::TableFunc* tablefunc_;
  ::pg_query::Alias* alias_;
  ::pg_query::Alias* eref_;
  int rtekind_;
  ::PROTOBUF_NAMESPACE_ID::uint32 relid_;
  ::PROTOBUF_NAMESPACE_ID::int32 rellockmode_;
  int jointype_;
  ::PROTOBUF_NAMESPACE_ID::int32 joinmergedcols_;
  bool security_barrier_;
  bool funcordinality_;
  bool self_reference_;
  bool lateral_;
  double enrtuples_;
  ::PROTOBUF_NAMESPACE_ID::uint32 ctelevelsup_;
  bool inh_;
  bool in_from_cl_;
  ::PROTOBUF_NAMESPACE_ID::uint32 required_perms_;
  ::PROTOBUF_NAMESPACE_ID::uint32 check_as_user_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RangeTblFunction PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTblFunction) */ {
 public:
  inline RangeTblFunction() : RangeTblFunction(nullptr) {}
  virtual ~RangeTblFunction();

  RangeTblFunction(const RangeTblFunction& from);
  RangeTblFunction(RangeTblFunction&& from) noexcept
    : RangeTblFunction() {
    *this = ::std::move(from);
  }

  inline RangeTblFunction& operator=(const RangeTblFunction& from) {
    CopyFrom(from);
    return *this;
  }
  inline RangeTblFunction& operator=(RangeTblFunction&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RangeTblFunction& default_instance();

  static inline const RangeTblFunction* internal_default_instance() {
    return reinterpret_cast<const RangeTblFunction*>(
               &_RangeTblFunction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    204;

  friend void swap(RangeTblFunction& a, RangeTblFunction& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeTblFunction* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeTblFunction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RangeTblFunction* New() const final {
    return CreateMaybeMessage<RangeTblFunction>(nullptr);
  }

  RangeTblFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RangeTblFunction>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RangeTblFunction& from);
  void MergeFrom(const RangeTblFunction& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RangeTblFunction* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RangeTblFunction";
  }
  protected:
  explicit RangeTblFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFunccolnamesFieldNumber = 3,
    kFunccoltypesFieldNumber = 4,
    kFunccoltypmodsFieldNumber = 5,
    kFunccolcollationsFieldNumber = 6,
    kFuncexprFieldNumber = 1,
    kFunccolcountFieldNumber = 2,
  };
  // repeated .pg_query.Node funccolnames = 3 [json_name = "funccolnames"];
  int funccolnames_size() const;
  private:
  int _internal_funccolnames_size() const;
  public:
  void clear_funccolnames();
  ::pg_query::Node* mutable_funccolnames(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_funccolnames();
  private:
  const ::pg_query::Node& _internal_funccolnames(int index) const;
  ::pg_query::Node* _internal_add_funccolnames();
  public:
  const ::pg_query::Node& funccolnames(int index) const;
  ::pg_query::Node* add_funccolnames();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      funccolnames() const;

  // repeated .pg_query.Node funccoltypes = 4 [json_name = "funccoltypes"];
  int funccoltypes_size() const;
  private:
  int _internal_funccoltypes_size() const;
  public:
  void clear_funccoltypes();
  ::pg_query::Node* mutable_funccoltypes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_funccoltypes();
  private:
  const ::pg_query::Node& _internal_funccoltypes(int index) const;
  ::pg_query::Node* _internal_add_funccoltypes();
  public:
  const ::pg_query::Node& funccoltypes(int index) const;
  ::pg_query::Node* add_funccoltypes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      funccoltypes() const;

  // repeated .pg_query.Node funccoltypmods = 5 [json_name = "funccoltypmods"];
  int funccoltypmods_size() const;
  private:
  int _internal_funccoltypmods_size() const;
  public:
  void clear_funccoltypmods();
  ::pg_query::Node* mutable_funccoltypmods(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_funccoltypmods();
  private:
  const ::pg_query::Node& _internal_funccoltypmods(int index) const;
  ::pg_query::Node* _internal_add_funccoltypmods();
  public:
  const ::pg_query::Node& funccoltypmods(int index) const;
  ::pg_query::Node* add_funccoltypmods();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      funccoltypmods() const;

  // repeated .pg_query.Node funccolcollations = 6 [json_name = "funccolcollations"];
  int funccolcollations_size() const;
  private:
  int _internal_funccolcollations_size() const;
  public:
  void clear_funccolcollations();
  ::pg_query::Node* mutable_funccolcollations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_funccolcollations();
  private:
  const ::pg_query::Node& _internal_funccolcollations(int index) const;
  ::pg_query::Node* _internal_add_funccolcollations();
  public:
  const ::pg_query::Node& funccolcollations(int index) const;
  ::pg_query::Node* add_funccolcollations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      funccolcollations() const;

  // .pg_query.Node funcexpr = 1 [json_name = "funcexpr"];
  bool has_funcexpr() const;
  private:
  bool _internal_has_funcexpr() const;
  public:
  void clear_funcexpr();
  const ::pg_query::Node& funcexpr() const;
  ::pg_query::Node* release_funcexpr();
  ::pg_query::Node* mutable_funcexpr();
  void set_allocated_funcexpr(::pg_query::Node* funcexpr);
  private:
  const ::pg_query::Node& _internal_funcexpr() const;
  ::pg_query::Node* _internal_mutable_funcexpr();
  public:
  void unsafe_arena_set_allocated_funcexpr(
      ::pg_query::Node* funcexpr);
  ::pg_query::Node* unsafe_arena_release_funcexpr();

  // int32 funccolcount = 2 [json_name = "funccolcount"];
  void clear_funccolcount();
  ::PROTOBUF_NAMESPACE_ID::int32 funccolcount() const;
  void set_funccolcount(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_funccolcount() const;
  void _internal_set_funccolcount(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RangeTblFunction)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funccolnames_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funccoltypes_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funccoltypmods_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funccolcollations_;
  ::pg_query::Node* funcexpr_;
  ::PROTOBUF_NAMESPACE_ID::int32 funccolcount_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class TableSampleClause PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TableSampleClause) */ {
 public:
  inline TableSampleClause() : TableSampleClause(nullptr) {}
  virtual ~TableSampleClause();

  TableSampleClause(const TableSampleClause& from);
  TableSampleClause(TableSampleClause&& from) noexcept
    : TableSampleClause() {
    *this = ::std::move(from);
  }

  inline TableSampleClause& operator=(const TableSampleClause& from) {
    CopyFrom(from);
    return *this;
  }
  inline TableSampleClause& operator=(TableSampleClause&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TableSampleClause& default_instance();

  static inline const TableSampleClause* internal_default_instance() {
    return reinterpret_cast<const TableSampleClause*>(
               &_TableSampleClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    205;

  friend void swap(TableSampleClause& a, TableSampleClause& b) {
    a.Swap(&b);
  }
  inline void Swap(TableSampleClause* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TableSampleClause* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TableSampleClause* New() const final {
    return CreateMaybeMessage<TableSampleClause>(nullptr);
  }

  TableSampleClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TableSampleClause>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TableSampleClause& from);
  void MergeFrom(const TableSampleClause& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TableSampleClause* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.TableSampleClause";
  }
  protected:
  explicit TableSampleClause(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kArgsFieldNumber = 2,
    kRepeatableFieldNumber = 3,
    kTsmhandlerFieldNumber = 1,
  };
  // repeated .pg_query.Node args = 2 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::pg_query::Node* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::pg_query::Node& _internal_args(int index) const;
  ::pg_query::Node* _internal_add_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      args() const;

  // .pg_query.Node repeatable = 3 [json_name = "repeatable"];
  bool has_repeatable() const;
  private:
  bool _internal_has_repeatable() const;
  public:
  void clear_repeatable();
  const ::pg_query::Node& repeatable() const;
  ::pg_query::Node* release_repeatable();
  ::pg_query::Node* mutable_repeatable();
  void set_allocated_repeatable(::pg_query::Node* repeatable);
  private:
  const ::pg_query::Node& _internal_repeatable() const;
  ::pg_query::Node* _internal_mutable_repeatable();
  public:
  void unsafe_arena_set_allocated_repeatable(
      ::pg_query::Node* repeatable);
  ::pg_query::Node* unsafe_arena_release_repeatable();

  // uint32 tsmhandler = 1 [json_name = "tsmhandler"];
  void clear_tsmhandler();
  ::PROTOBUF_NAMESPACE_ID::uint32 tsmhandler() const;
  void set_tsmhandler(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_tsmhandler() const;
  void _internal_set_tsmhandler(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.TableSampleClause)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_;
  ::pg_query::Node* repeatable_;
  ::PROTOBUF_NAMESPACE_ID::uint32 tsmhandler_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class WithCheckOption PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.WithCheckOption) */ {
 public:
  inline WithCheckOption() : WithCheckOption(nullptr) {}
  virtual ~WithCheckOption();

  WithCheckOption(const WithCheckOption& from);
  WithCheckOption(WithCheckOption&& from) noexcept
    : WithCheckOption() {
    *this = ::std::move(from);
  }

  inline WithCheckOption& operator=(const WithCheckOption& from) {
    CopyFrom(from);
    return *this;
  }
  inline WithCheckOption& operator=(WithCheckOption&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const WithCheckOption& default_instance();

  static inline const WithCheckOption* internal_default_instance() {
    return reinterpret_cast<const WithCheckOption*>(
               &_WithCheckOption_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    206;

  friend void swap(WithCheckOption& a, WithCheckOption& b) {
    a.Swap(&b);
  }
  inline void Swap(WithCheckOption* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(WithCheckOption* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline WithCheckOption* New() const final {
    return CreateMaybeMessage<WithCheckOption>(nullptr);
  }

  WithCheckOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WithCheckOption>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WithCheckOption& from);
  void MergeFrom(const WithCheckOption& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WithCheckOption* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.WithCheckOption";
  }
  protected:
  explicit WithCheckOption(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRelnameFieldNumber = 2,
    kPolnameFieldNumber = 3,
    kQualFieldNumber = 4,
    kKindFieldNumber = 1,
    kCascadedFieldNumber = 5,
  };
  // string relname = 2 [json_name = "relname"];
  void clear_relname();
  const std::string& relname() const;
  void set_relname(const std::string& value);
  void set_relname(std::string&& value);
  void set_relname(const char* value);
  void set_relname(const char* value, size_t size);
  std::string* mutable_relname();
  std::string* release_relname();
  void set_allocated_relname(std::string* relname);
  private:
  const std::string& _internal_relname() const;
  void _internal_set_relname(const std::string& value);
  std::string* _internal_mutable_relname();
  public:

  // string polname = 3 [json_name = "polname"];
  void clear_polname();
  const std::string& polname() const;
  void set_polname(const std::string& value);
  void set_polname(std::string&& value);
  void set_polname(const char* value);
  void set_polname(const char* value, size_t size);
  std::string* mutable_polname();
  std::string* release_polname();
  void set_allocated_polname(std::string* polname);
  private:
  const std::string& _internal_polname() const;
  void _internal_set_polname(const std::string& value);
  std::string* _internal_mutable_polname();
  public:

  // .pg_query.Node qual = 4 [json_name = "qual"];
  bool has_qual() const;
  private:
  bool _internal_has_qual() const;
  public:
  void clear_qual();
  const ::pg_query::Node& qual() const;
  ::pg_query::Node* release_qual();
  ::pg_query::Node* mutable_qual();
  void set_allocated_qual(::pg_query::Node* qual);
  private:
  const ::pg_query::Node& _internal_qual() const;
  ::pg_query::Node* _internal_mutable_qual();
  public:
  void unsafe_arena_set_allocated_qual(
      ::pg_query::Node* qual);
  ::pg_query::Node* unsafe_arena_release_qual();

  // .pg_query.WCOKind kind = 1 [json_name = "kind"];
  void clear_kind();
  ::pg_query::WCOKind kind() const;
  void set_kind(::pg_query::WCOKind value);
  private:
  ::pg_query::WCOKind _internal_kind() const;
  void _internal_set_kind(::pg_query::WCOKind value);
  public:

  // bool cascaded = 5 [json_name = "cascaded"];
  void clear_cascaded();
  bool cascaded() const;
  void set_cascaded(bool value);
  private:
  bool _internal_cascaded() const;
  void _internal_set_cascaded(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.WithCheckOption)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr relname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr polname_;
  ::pg_query::Node* qual_;
  int kind_;
  bool cascaded_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class SortGroupClause PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SortGroupClause) */ {
 public:
  inline SortGroupClause() : SortGroupClause(nullptr) {}
  virtual ~SortGroupClause();

  SortGroupClause(const SortGroupClause& from);
  SortGroupClause(SortGroupClause&& from) noexcept
    : SortGroupClause() {
    *this = ::std::move(from);
  }

  inline SortGroupClause& operator=(const SortGroupClause& from) {
    CopyFrom(from);
    return *this;
  }
  inline SortGroupClause& operator=(SortGroupClause&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SortGroupClause& default_instance();

  static inline const SortGroupClause* internal_default_instance() {
    return reinterpret_cast<const SortGroupClause*>(
               &_SortGroupClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    207;

  friend void swap(SortGroupClause& a, SortGroupClause& b) {
    a.Swap(&b);
  }
  inline void Swap(SortGroupClause* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SortGroupClause* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline SortGroupClause* New() const final {
    return CreateMaybeMessage<SortGroupClause>(nullptr);
  }

  SortGroupClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SortGroupClause>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SortGroupClause& from);
  void MergeFrom(const SortGroupClause& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SortGroupClause* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.SortGroupClause";
  }
  protected:
  explicit SortGroupClause(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTleSortGroupRefFieldNumber = 1,
    kEqopFieldNumber = 2,
    kSortopFieldNumber = 3,
    kNullsFirstFieldNumber = 4,
    kHashableFieldNumber = 5,
  };
  // uint32 tle_sort_group_ref = 1 [json_name = "tleSortGroupRef"];
  void clear_tle_sort_group_ref();
  ::PROTOBUF_NAMESPACE_ID::uint32 tle_sort_group_ref() const;
  void set_tle_sort_group_ref(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_tle_sort_group_ref() const;
  void _internal_set_tle_sort_group_ref(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 eqop = 2 [json_name = "eqop"];
  void clear_eqop();
  ::PROTOBUF_NAMESPACE_ID::uint32 eqop() const;
  void set_eqop(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_eqop() const;
  void _internal_set_eqop(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 sortop = 3 [json_name = "sortop"];
  void clear_sortop();
  ::PROTOBUF_NAMESPACE_ID::uint32 sortop() const;
  void set_sortop(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_sortop() const;
  void _internal_set_sortop(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool nulls_first = 4 [json_name = "nulls_first"];
  void clear_nulls_first();
  bool nulls_first() const;
  void set_nulls_first(bool value);
  private:
  bool _internal_nulls_first() const;
  void _internal_set_nulls_first(bool value);
  public:

  // bool hashable = 5 [json_name = "hashable"];
  void clear_hashable();
  bool hashable() const;
  void set_hashable(bool value);
  private:
  bool _internal_hashable() const;
  void _internal_set_hashable(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.SortGroupClause)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint32 tle_sort_group_ref_;
  ::PROTOBUF_NAMESPACE_ID::uint32 eqop_;
  ::PROTOBUF_NAMESPACE_ID::uint32 sortop_;
  bool nulls_first_;
  bool hashable_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class GroupingSet PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.GroupingSet) */ {
 public:
  inline GroupingSet() : GroupingSet(nullptr) {}
  virtual ~GroupingSet();

  GroupingSet(const GroupingSet& from);
  GroupingSet(GroupingSet&& from) noexcept
    : GroupingSet() {
    *this = ::std::move(from);
  }

  inline GroupingSet& operator=(const GroupingSet& from) {
    CopyFrom(from);
    return *this;
  }
  inline GroupingSet& operator=(GroupingSet&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GroupingSet& default_instance();

  static inline const GroupingSet* internal_default_instance() {
    return reinterpret_cast<const GroupingSet*>(
               &_GroupingSet_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    208;

  friend void swap(GroupingSet& a, GroupingSet& b) {
    a.Swap(&b);
  }
  inline void Swap(GroupingSet* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GroupingSet* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GroupingSet* New() const final {
    return CreateMaybeMessage<GroupingSet>(nullptr);
  }

  GroupingSet* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GroupingSet>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GroupingSet& from);
  void MergeFrom(const GroupingSet& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GroupingSet* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.GroupingSet";
  }
  protected:
  explicit GroupingSet(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kContentFieldNumber = 2,
    kKindFieldNumber = 1,
    kLocationFieldNumber = 3,
  };
  // repeated .pg_query.Node content = 2 [json_name = "content"];
  int content_size() const;
  private:
  int _internal_content_size() const;
  public:
  void clear_content();
  ::pg_query::Node* mutable_content(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_content();
  private:
  const ::pg_query::Node& _internal_content(int index) const;
  ::pg_query::Node* _internal_add_content();
  public:
  const ::pg_query::Node& content(int index) const;
  ::pg_query::Node* add_content();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      content() const;

  // .pg_query.GroupingSetKind kind = 1 [json_name = "kind"];
  void clear_kind();
  ::pg_query::GroupingSetKind kind() const;
  void set_kind(::pg_query::GroupingSetKind value);
  private:
  ::pg_query::GroupingSetKind _internal_kind() const;
  void _internal_set_kind(::pg_query::GroupingSetKind value);
  public:

  // int32 location = 3 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.GroupingSet)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > content_;
  int kind_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class WindowClause PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.WindowClause) */ {
 public:
  inline WindowClause() : WindowClause(nullptr) {}
  virtual ~WindowClause();

  WindowClause(const WindowClause& from);
  WindowClause(WindowClause&& from) noexcept
    : WindowClause() {
    *this = ::std::move(from);
  }

  inline WindowClause& operator=(const WindowClause& from) {
    CopyFrom(from);
    return *this;
  }
  inline WindowClause& operator=(WindowClause&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const WindowClause& default_instance();

  static inline const WindowClause* internal_default_instance() {
    return reinterpret_cast<const WindowClause*>(
               &_WindowClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    209;

  friend void swap(WindowClause& a, WindowClause& b) {
    a.Swap(&b);
  }
  inline void Swap(WindowClause* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(WindowClause* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline WindowClause* New() const final {
    return CreateMaybeMessage<WindowClause>(nullptr);
  }

  WindowClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WindowClause>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WindowClause& from);
  void MergeFrom(const WindowClause& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WindowClause* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.WindowClause";
  }
  protected:
  explicit WindowClause(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPartitionClauseFieldNumber = 3,
    kOrderClauseFieldNumber = 4,
    kNameFieldNumber = 1,
    kRefnameFieldNumber = 2,
    kStartOffsetFieldNumber = 6,
    kEndOffsetFieldNumber = 7,
    kFrameOptionsFieldNumber = 5,
    kStartInRangeFuncFieldNumber = 8,
    kEndInRangeFuncFieldNumber = 9,
    kInRangeCollFieldNumber = 10,
    kInRangeAscFieldNumber = 11,
    kInRangeNullsFirstFieldNumber = 12,
    kCopiedOrderFieldNumber = 14,
    kWinrefFieldNumber = 13,
  };
  // repeated .pg_query.Node partition_clause = 3 [json_name = "partitionClause"];
  int partition_clause_size() const;
  private:
  int _internal_partition_clause_size() const;
  public:
  void clear_partition_clause();
  ::pg_query::Node* mutable_partition_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_partition_clause();
  private:
  const ::pg_query::Node& _internal_partition_clause(int index) const;
  ::pg_query::Node* _internal_add_partition_clause();
  public:
  const ::pg_query::Node& partition_clause(int index) const;
  ::pg_query::Node* add_partition_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      partition_clause() const;

  // repeated .pg_query.Node order_clause = 4 [json_name = "orderClause"];
  int order_clause_size() const;
  private:
  int _internal_order_clause_size() const;
  public:
  void clear_order_clause();
  ::pg_query::Node* mutable_order_clause(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_order_clause();
  private:
  const ::pg_query::Node& _internal_order_clause(int index) const;
  ::pg_query::Node* _internal_add_order_clause();
  public:
  const ::pg_query::Node& order_clause(int index) const;
  ::pg_query::Node* add_order_clause();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      order_clause() const;

  // string name = 1 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string refname = 2 [json_name = "refname"];
  void clear_refname();
  const std::string& refname() const;
  void set_refname(const std::string& value);
  void set_refname(std::string&& value);
  void set_refname(const char* value);
  void set_refname(const char* value, size_t size);
  std::string* mutable_refname();
  std::string* release_refname();
  void set_allocated_refname(std::string* refname);
  private:
  const std::string& _internal_refname() const;
  void _internal_set_refname(const std::string& value);
  std::string* _internal_mutable_refname();
  public:

  // .pg_query.Node start_offset = 6 [json_name = "startOffset"];
  bool has_start_offset() const;
  private:
  bool _internal_has_start_offset() const;
  public:
  void clear_start_offset();
  const ::pg_query::Node& start_offset() const;
  ::pg_query::Node* release_start_offset();
  ::pg_query::Node* mutable_start_offset();
  void set_allocated_start_offset(::pg_query::Node* start_offset);
  private:
  const ::pg_query::Node& _internal_start_offset() const;
  ::pg_query::Node* _internal_mutable_start_offset();
  public:
  void unsafe_arena_set_allocated_start_offset(
      ::pg_query::Node* start_offset);
  ::pg_query::Node* unsafe_arena_release_start_offset();

  // .pg_query.Node end_offset = 7 [json_name = "endOffset"];
  bool has_end_offset() const;
  private:
  bool _internal_has_end_offset() const;
  public:
  void clear_end_offset();
  const ::pg_query::Node& end_offset() const;
  ::pg_query::Node* release_end_offset();
  ::pg_query::Node* mutable_end_offset();
  void set_allocated_end_offset(::pg_query::Node* end_offset);
  private:
  const ::pg_query::Node& _internal_end_offset() const;
  ::pg_query::Node* _internal_mutable_end_offset();
  public:
  void unsafe_arena_set_allocated_end_offset(
      ::pg_query::Node* end_offset);
  ::pg_query::Node* unsafe_arena_release_end_offset();

  // int32 frame_options = 5 [json_name = "frameOptions"];
  void clear_frame_options();
  ::PROTOBUF_NAMESPACE_ID::int32 frame_options() const;
  void set_frame_options(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_frame_options() const;
  void _internal_set_frame_options(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 start_in_range_func = 8 [json_name = "startInRangeFunc"];
  void clear_start_in_range_func();
  ::PROTOBUF_NAMESPACE_ID::uint32 start_in_range_func() const;
  void set_start_in_range_func(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_start_in_range_func() const;
  void _internal_set_start_in_range_func(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 end_in_range_func = 9 [json_name = "endInRangeFunc"];
  void clear_end_in_range_func();
  ::PROTOBUF_NAMESPACE_ID::uint32 end_in_range_func() const;
  void set_end_in_range_func(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_end_in_range_func() const;
  void _internal_set_end_in_range_func(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 in_range_coll = 10 [json_name = "inRangeColl"];
  void clear_in_range_coll();
  ::PROTOBUF_NAMESPACE_ID::uint32 in_range_coll() const;
  void set_in_range_coll(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_in_range_coll() const;
  void _internal_set_in_range_coll(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool in_range_asc = 11 [json_name = "inRangeAsc"];
  void clear_in_range_asc();
  bool in_range_asc() const;
  void set_in_range_asc(bool value);
  private:
  bool _internal_in_range_asc() const;
  void _internal_set_in_range_asc(bool value);
  public:

  // bool in_range_nulls_first = 12 [json_name = "inRangeNullsFirst"];
  void clear_in_range_nulls_first();
  bool in_range_nulls_first() const;
  void set_in_range_nulls_first(bool value);
  private:
  bool _internal_in_range_nulls_first() const;
  void _internal_set_in_range_nulls_first(bool value);
  public:

  // bool copied_order = 14 [json_name = "copiedOrder"];
  void clear_copied_order();
  bool copied_order() const;
  void set_copied_order(bool value);
  private:
  bool _internal_copied_order() const;
  void _internal_set_copied_order(bool value);
  public:

  // uint32 winref = 13 [json_name = "winref"];
  void clear_winref();
  ::PROTOBUF_NAMESPACE_ID::uint32 winref() const;
  void set_winref(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_winref() const;
  void _internal_set_winref(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.WindowClause)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > partition_clause_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > order_clause_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr refname_;
  ::pg_query::Node* start_offset_;
  ::pg_query::Node* end_offset_;
  ::PROTOBUF_NAMESPACE_ID::int32 frame_options_;
  ::PROTOBUF_NAMESPACE_ID::uint32 start_in_range_func_;
  ::PROTOBUF_NAMESPACE_ID::uint32 end_in_range_func_;
  ::PROTOBUF_NAMESPACE_ID::uint32 in_range_coll_;
  bool in_range_asc_;
  bool in_range_nulls_first_;
  bool copied_order_;
  ::PROTOBUF_NAMESPACE_ID::uint32 winref_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ObjectWithArgs PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ObjectWithArgs) */ {
 public:
  inline ObjectWithArgs() : ObjectWithArgs(nullptr) {}
  virtual ~ObjectWithArgs();

  ObjectWithArgs(const ObjectWithArgs& from);
  ObjectWithArgs(ObjectWithArgs&& from) noexcept
    : ObjectWithArgs() {
    *this = ::std::move(from);
  }

  inline ObjectWithArgs& operator=(const ObjectWithArgs& from) {
    CopyFrom(from);
    return *this;
  }
  inline ObjectWithArgs& operator=(ObjectWithArgs&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ObjectWithArgs& default_instance();

  static inline const ObjectWithArgs* internal_default_instance() {
    return reinterpret_cast<const ObjectWithArgs*>(
               &_ObjectWithArgs_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    210;

  friend void swap(ObjectWithArgs& a, ObjectWithArgs& b) {
    a.Swap(&b);
  }
  inline void Swap(ObjectWithArgs* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ObjectWithArgs* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ObjectWithArgs* New() const final {
    return CreateMaybeMessage<ObjectWithArgs>(nullptr);
  }

  ObjectWithArgs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ObjectWithArgs>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ObjectWithArgs& from);
  void MergeFrom(const ObjectWithArgs& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ObjectWithArgs* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ObjectWithArgs";
  }
  protected:
  explicit ObjectWithArgs(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kObjnameFieldNumber = 1,
    kObjargsFieldNumber = 2,
    kArgsUnspecifiedFieldNumber = 3,
  };
  // repeated .pg_query.Node objname = 1 [json_name = "objname"];
  int objname_size() const;
  private:
  int _internal_objname_size() const;
  public:
  void clear_objname();
  ::pg_query::Node* mutable_objname(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_objname();
  private:
  const ::pg_query::Node& _internal_objname(int index) const;
  ::pg_query::Node* _internal_add_objname();
  public:
  const ::pg_query::Node& objname(int index) const;
  ::pg_query::Node* add_objname();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      objname() const;

  // repeated .pg_query.Node objargs = 2 [json_name = "objargs"];
  int objargs_size() const;
  private:
  int _internal_objargs_size() const;
  public:
  void clear_objargs();
  ::pg_query::Node* mutable_objargs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_objargs();
  private:
  const ::pg_query::Node& _internal_objargs(int index) const;
  ::pg_query::Node* _internal_add_objargs();
  public:
  const ::pg_query::Node& objargs(int index) const;
  ::pg_query::Node* add_objargs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      objargs() const;

  // bool args_unspecified = 3 [json_name = "args_unspecified"];
  void clear_args_unspecified();
  bool args_unspecified() const;
  void set_args_unspecified(bool value);
  private:
  bool _internal_args_unspecified() const;
  void _internal_set_args_unspecified(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ObjectWithArgs)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > objname_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > objargs_;
  bool args_unspecified_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class AccessPriv PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AccessPriv) */ {
 public:
  inline AccessPriv() : AccessPriv(nullptr) {}
  virtual ~AccessPriv();

  AccessPriv(const AccessPriv& from);
  AccessPriv(AccessPriv&& from) noexcept
    : AccessPriv() {
    *this = ::std::move(from);
  }

  inline AccessPriv& operator=(const AccessPriv& from) {
    CopyFrom(from);
    return *this;
  }
  inline AccessPriv& operator=(AccessPriv&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AccessPriv& default_instance();

  static inline const AccessPriv* internal_default_instance() {
    return reinterpret_cast<const AccessPriv*>(
               &_AccessPriv_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    211;

  friend void swap(AccessPriv& a, AccessPriv& b) {
    a.Swap(&b);
  }
  inline void Swap(AccessPriv* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AccessPriv* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline AccessPriv* New() const final {
    return CreateMaybeMessage<AccessPriv>(nullptr);
  }

  AccessPriv* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AccessPriv>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AccessPriv& from);
  void MergeFrom(const AccessPriv& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AccessPriv* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.AccessPriv";
  }
  protected:
  explicit AccessPriv(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kColsFieldNumber = 2,
    kPrivNameFieldNumber = 1,
  };
  // repeated .pg_query.Node cols = 2 [json_name = "cols"];
  int cols_size() const;
  private:
  int _internal_cols_size() const;
  public:
  void clear_cols();
  ::pg_query::Node* mutable_cols(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_cols();
  private:
  const ::pg_query::Node& _internal_cols(int index) const;
  ::pg_query::Node* _internal_add_cols();
  public:
  const ::pg_query::Node& cols(int index) const;
  ::pg_query::Node* add_cols();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      cols() const;

  // string priv_name = 1 [json_name = "priv_name"];
  void clear_priv_name();
  const std::string& priv_name() const;
  void set_priv_name(const std::string& value);
  void set_priv_name(std::string&& value);
  void set_priv_name(const char* value);
  void set_priv_name(const char* value, size_t size);
  std::string* mutable_priv_name();
  std::string* release_priv_name();
  void set_allocated_priv_name(std::string* priv_name);
  private:
  const std::string& _internal_priv_name() const;
  void _internal_set_priv_name(const std::string& value);
  std::string* _internal_mutable_priv_name();
  public:

  // @@protoc_insertion_point(class_scope:pg_query.AccessPriv)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > cols_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr priv_name_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CreateOpClassItem PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateOpClassItem) */ {
 public:
  inline CreateOpClassItem() : CreateOpClassItem(nullptr) {}
  virtual ~CreateOpClassItem();

  CreateOpClassItem(const CreateOpClassItem& from);
  CreateOpClassItem(CreateOpClassItem&& from) noexcept
    : CreateOpClassItem() {
    *this = ::std::move(from);
  }

  inline CreateOpClassItem& operator=(const CreateOpClassItem& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateOpClassItem& operator=(CreateOpClassItem&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CreateOpClassItem& default_instance();

  static inline const CreateOpClassItem* internal_default_instance() {
    return reinterpret_cast<const CreateOpClassItem*>(
               &_CreateOpClassItem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    212;

  friend void swap(CreateOpClassItem& a, CreateOpClassItem& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateOpClassItem* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateOpClassItem* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreateOpClassItem* New() const final {
    return CreateMaybeMessage<CreateOpClassItem>(nullptr);
  }

  CreateOpClassItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateOpClassItem>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateOpClassItem& from);
  void MergeFrom(const CreateOpClassItem& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateOpClassItem* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CreateOpClassItem";
  }
  protected:
  explicit CreateOpClassItem(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOrderFamilyFieldNumber = 4,
    kClassArgsFieldNumber = 5,
    kNameFieldNumber = 2,
    kStoredtypeFieldNumber = 6,
    kItemtypeFieldNumber = 1,
    kNumberFieldNumber = 3,
  };
  // repeated .pg_query.Node order_family = 4 [json_name = "order_family"];
  int order_family_size() const;
  private:
  int _internal_order_family_size() const;
  public:
  void clear_order_family();
  ::pg_query::Node* mutable_order_family(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_order_family();
  private:
  const ::pg_query::Node& _internal_order_family(int index) const;
  ::pg_query::Node* _internal_add_order_family();
  public:
  const ::pg_query::Node& order_family(int index) const;
  ::pg_query::Node* add_order_family();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      order_family() const;

  // repeated .pg_query.Node class_args = 5 [json_name = "class_args"];
  int class_args_size() const;
  private:
  int _internal_class_args_size() const;
  public:
  void clear_class_args();
  ::pg_query::Node* mutable_class_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_class_args();
  private:
  const ::pg_query::Node& _internal_class_args(int index) const;
  ::pg_query::Node* _internal_add_class_args();
  public:
  const ::pg_query::Node& class_args(int index) const;
  ::pg_query::Node* add_class_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      class_args() const;

  // .pg_query.ObjectWithArgs name = 2 [json_name = "name"];
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const ::pg_query::ObjectWithArgs& name() const;
  ::pg_query::ObjectWithArgs* release_name();
  ::pg_query::ObjectWithArgs* mutable_name();
  void set_allocated_name(::pg_query::ObjectWithArgs* name);
  private:
  const ::pg_query::ObjectWithArgs& _internal_name() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_name();
  public:
  void unsafe_arena_set_allocated_name(
      ::pg_query::ObjectWithArgs* name);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_name();

  // .pg_query.TypeName storedtype = 6 [json_name = "storedtype"];
  bool has_storedtype() const;
  private:
  bool _internal_has_storedtype() const;
  public:
  void clear_storedtype();
  const ::pg_query::TypeName& storedtype() const;
  ::pg_query::TypeName* release_storedtype();
  ::pg_query::TypeName* mutable_storedtype();
  void set_allocated_storedtype(::pg_query::TypeName* storedtype);
  private:
  const ::pg_query::TypeName& _internal_storedtype() const;
  ::pg_query::TypeName* _internal_mutable_storedtype();
  public:
  void unsafe_arena_set_allocated_storedtype(
      ::pg_query::TypeName* storedtype);
  ::pg_query::TypeName* unsafe_arena_release_storedtype();

  // int32 itemtype = 1 [json_name = "itemtype"];
  void clear_itemtype();
  ::PROTOBUF_NAMESPACE_ID::int32 itemtype() const;
  void set_itemtype(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_itemtype() const;
  void _internal_set_itemtype(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 number = 3 [json_name = "number"];
  void clear_number();
  ::PROTOBUF_NAMESPACE_ID::int32 number() const;
  void set_number(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_number() const;
  void _internal_set_number(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CreateOpClassItem)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > order_family_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > class_args_;
  ::pg_query::ObjectWithArgs* name_;
  ::pg_query::TypeName* storedtype_;
  ::PROTOBUF_NAMESPACE_ID::int32 itemtype_;
  ::PROTOBUF_NAMESPACE_ID::int32 number_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class TableLikeClause PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TableLikeClause) */ {
 public:
  inline TableLikeClause() : TableLikeClause(nullptr) {}
  virtual ~TableLikeClause();

  TableLikeClause(const TableLikeClause& from);
  TableLikeClause(TableLikeClause&& from) noexcept
    : TableLikeClause() {
    *this = ::std::move(from);
  }

  inline TableLikeClause& operator=(const TableLikeClause& from) {
    CopyFrom(from);
    return *this;
  }
  inline TableLikeClause& operator=(TableLikeClause&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TableLikeClause& default_instance();

  static inline const TableLikeClause* internal_default_instance() {
    return reinterpret_cast<const TableLikeClause*>(
               &_TableLikeClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    213;

  friend void swap(TableLikeClause& a, TableLikeClause& b) {
    a.Swap(&b);
  }
  inline void Swap(TableLikeClause* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TableLikeClause* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TableLikeClause* New() const final {
    return CreateMaybeMessage<TableLikeClause>(nullptr);
  }

  TableLikeClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TableLikeClause>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TableLikeClause& from);
  void MergeFrom(const TableLikeClause& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TableLikeClause* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.TableLikeClause";
  }
  protected:
  explicit TableLikeClause(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRelationFieldNumber = 1,
    kOptionsFieldNumber = 2,
  };
  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // uint32 options = 2 [json_name = "options"];
  void clear_options();
  ::PROTOBUF_NAMESPACE_ID::uint32 options() const;
  void set_options(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_options() const;
  void _internal_set_options(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.TableLikeClause)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::RangeVar* relation_;
  ::PROTOBUF_NAMESPACE_ID::uint32 options_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class FunctionParameter PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FunctionParameter) */ {
 public:
  inline FunctionParameter() : FunctionParameter(nullptr) {}
  virtual ~FunctionParameter();

  FunctionParameter(const FunctionParameter& from);
  FunctionParameter(FunctionParameter&& from) noexcept
    : FunctionParameter() {
    *this = ::std::move(from);
  }

  inline FunctionParameter& operator=(const FunctionParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionParameter& operator=(FunctionParameter&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const FunctionParameter& default_instance();

  static inline const FunctionParameter* internal_default_instance() {
    return reinterpret_cast<const FunctionParameter*>(
               &_FunctionParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    214;

  friend void swap(FunctionParameter& a, FunctionParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionParameter* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline FunctionParameter* New() const final {
    return CreateMaybeMessage<FunctionParameter>(nullptr);
  }

  FunctionParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FunctionParameter>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const FunctionParameter& from);
  void MergeFrom(const FunctionParameter& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FunctionParameter* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.FunctionParameter";
  }
  protected:
  explicit FunctionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kArgTypeFieldNumber = 2,
    kDefexprFieldNumber = 4,
    kModeFieldNumber = 3,
  };
  // string name = 1 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .pg_query.TypeName arg_type = 2 [json_name = "argType"];
  bool has_arg_type() const;
  private:
  bool _internal_has_arg_type() const;
  public:
  void clear_arg_type();
  const ::pg_query::TypeName& arg_type() const;
  ::pg_query::TypeName* release_arg_type();
  ::pg_query::TypeName* mutable_arg_type();
  void set_allocated_arg_type(::pg_query::TypeName* arg_type);
  private:
  const ::pg_query::TypeName& _internal_arg_type() const;
  ::pg_query::TypeName* _internal_mutable_arg_type();
  public:
  void unsafe_arena_set_allocated_arg_type(
      ::pg_query::TypeName* arg_type);
  ::pg_query::TypeName* unsafe_arena_release_arg_type();

  // .pg_query.Node defexpr = 4 [json_name = "defexpr"];
  bool has_defexpr() const;
  private:
  bool _internal_has_defexpr() const;
  public:
  void clear_defexpr();
  const ::pg_query::Node& defexpr() const;
  ::pg_query::Node* release_defexpr();
  ::pg_query::Node* mutable_defexpr();
  void set_allocated_defexpr(::pg_query::Node* defexpr);
  private:
  const ::pg_query::Node& _internal_defexpr() const;
  ::pg_query::Node* _internal_mutable_defexpr();
  public:
  void unsafe_arena_set_allocated_defexpr(
      ::pg_query::Node* defexpr);
  ::pg_query::Node* unsafe_arena_release_defexpr();

  // .pg_query.FunctionParameterMode mode = 3 [json_name = "mode"];
  void clear_mode();
  ::pg_query::FunctionParameterMode mode() const;
  void set_mode(::pg_query::FunctionParameterMode value);
  private:
  ::pg_query::FunctionParameterMode _internal_mode() const;
  void _internal_set_mode(::pg_query::FunctionParameterMode value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.FunctionParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::pg_query::TypeName* arg_type_;
  ::pg_query::Node* defexpr_;
  int mode_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class LockingClause PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.LockingClause) */ {
 public:
  inline LockingClause() : LockingClause(nullptr) {}
  virtual ~LockingClause();

  LockingClause(const LockingClause& from);
  LockingClause(LockingClause&& from) noexcept
    : LockingClause() {
    *this = ::std::move(from);
  }

  inline LockingClause& operator=(const LockingClause& from) {
    CopyFrom(from);
    return *this;
  }
  inline LockingClause& operator=(LockingClause&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LockingClause& default_instance();

  static inline const LockingClause* internal_default_instance() {
    return reinterpret_cast<const LockingClause*>(
               &_LockingClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    215;

  friend void swap(LockingClause& a, LockingClause& b) {
    a.Swap(&b);
  }
  inline void Swap(LockingClause* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LockingClause* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline LockingClause* New() const final {
    return CreateMaybeMessage<LockingClause>(nullptr);
  }

  LockingClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LockingClause>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LockingClause& from);
  void MergeFrom(const LockingClause& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LockingClause* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.LockingClause";
  }
  protected:
  explicit LockingClause(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLockedRelsFieldNumber = 1,
    kStrengthFieldNumber = 2,
    kWaitPolicyFieldNumber = 3,
  };
  // repeated .pg_query.Node locked_rels = 1 [json_name = "lockedRels"];
  int locked_rels_size() const;
  private:
  int _internal_locked_rels_size() const;
  public:
  void clear_locked_rels();
  ::pg_query::Node* mutable_locked_rels(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_locked_rels();
  private:
  const ::pg_query::Node& _internal_locked_rels(int index) const;
  ::pg_query::Node* _internal_add_locked_rels();
  public:
  const ::pg_query::Node& locked_rels(int index) const;
  ::pg_query::Node* add_locked_rels();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      locked_rels() const;

  // .pg_query.LockClauseStrength strength = 2 [json_name = "strength"];
  void clear_strength();
  ::pg_query::LockClauseStrength strength() const;
  void set_strength(::pg_query::LockClauseStrength value);
  private:
  ::pg_query::LockClauseStrength _internal_strength() const;
  void _internal_set_strength(::pg_query::LockClauseStrength value);
  public:

  // .pg_query.LockWaitPolicy wait_policy = 3 [json_name = "waitPolicy"];
  void clear_wait_policy();
  ::pg_query::LockWaitPolicy wait_policy() const;
  void set_wait_policy(::pg_query::LockWaitPolicy value);
  private:
  ::pg_query::LockWaitPolicy _internal_wait_policy() const;
  void _internal_set_wait_policy(::pg_query::LockWaitPolicy value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.LockingClause)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > locked_rels_;
  int strength_;
  int wait_policy_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RowMarkClause PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RowMarkClause) */ {
 public:
  inline RowMarkClause() : RowMarkClause(nullptr) {}
  virtual ~RowMarkClause();

  RowMarkClause(const RowMarkClause& from);
  RowMarkClause(RowMarkClause&& from) noexcept
    : RowMarkClause() {
    *this = ::std::move(from);
  }

  inline RowMarkClause& operator=(const RowMarkClause& from) {
    CopyFrom(from);
    return *this;
  }
  inline RowMarkClause& operator=(RowMarkClause&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RowMarkClause& default_instance();

  static inline const RowMarkClause* internal_default_instance() {
    return reinterpret_cast<const RowMarkClause*>(
               &_RowMarkClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    216;

  friend void swap(RowMarkClause& a, RowMarkClause& b) {
    a.Swap(&b);
  }
  inline void Swap(RowMarkClause* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RowMarkClause* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RowMarkClause* New() const final {
    return CreateMaybeMessage<RowMarkClause>(nullptr);
  }

  RowMarkClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RowMarkClause>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RowMarkClause& from);
  void MergeFrom(const RowMarkClause& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RowMarkClause* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RowMarkClause";
  }
  protected:
  explicit RowMarkClause(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRtiFieldNumber = 1,
    kStrengthFieldNumber = 2,
    kWaitPolicyFieldNumber = 3,
    kPushedDownFieldNumber = 4,
  };
  // uint32 rti = 1 [json_name = "rti"];
  void clear_rti();
  ::PROTOBUF_NAMESPACE_ID::uint32 rti() const;
  void set_rti(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_rti() const;
  void _internal_set_rti(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .pg_query.LockClauseStrength strength = 2 [json_name = "strength"];
  void clear_strength();
  ::pg_query::LockClauseStrength strength() const;
  void set_strength(::pg_query::LockClauseStrength value);
  private:
  ::pg_query::LockClauseStrength _internal_strength() const;
  void _internal_set_strength(::pg_query::LockClauseStrength value);
  public:

  // .pg_query.LockWaitPolicy wait_policy = 3 [json_name = "waitPolicy"];
  void clear_wait_policy();
  ::pg_query::LockWaitPolicy wait_policy() const;
  void set_wait_policy(::pg_query::LockWaitPolicy value);
  private:
  ::pg_query::LockWaitPolicy _internal_wait_policy() const;
  void _internal_set_wait_policy(::pg_query::LockWaitPolicy value);
  public:

  // bool pushed_down = 4 [json_name = "pushedDown"];
  void clear_pushed_down();
  bool pushed_down() const;
  void set_pushed_down(bool value);
  private:
  bool _internal_pushed_down() const;
  void _internal_set_pushed_down(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RowMarkClause)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint32 rti_;
  int strength_;
  int wait_policy_;
  bool pushed_down_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class XmlSerialize PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.XmlSerialize) */ {
 public:
  inline XmlSerialize() : XmlSerialize(nullptr) {}
  virtual ~XmlSerialize();

  XmlSerialize(const XmlSerialize& from);
  XmlSerialize(XmlSerialize&& from) noexcept
    : XmlSerialize() {
    *this = ::std::move(from);
  }

  inline XmlSerialize& operator=(const XmlSerialize& from) {
    CopyFrom(from);
    return *this;
  }
  inline XmlSerialize& operator=(XmlSerialize&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const XmlSerialize& default_instance();

  static inline const XmlSerialize* internal_default_instance() {
    return reinterpret_cast<const XmlSerialize*>(
               &_XmlSerialize_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    217;

  friend void swap(XmlSerialize& a, XmlSerialize& b) {
    a.Swap(&b);
  }
  inline void Swap(XmlSerialize* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(XmlSerialize* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline XmlSerialize* New() const final {
    return CreateMaybeMessage<XmlSerialize>(nullptr);
  }

  XmlSerialize* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<XmlSerialize>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const XmlSerialize& from);
  void MergeFrom(const XmlSerialize& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(XmlSerialize* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.XmlSerialize";
  }
  protected:
  explicit XmlSerialize(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kExprFieldNumber = 2,
    kTypeNameFieldNumber = 3,
    kXmloptionFieldNumber = 1,
    kLocationFieldNumber = 4,
  };
  // .pg_query.Node expr = 2 [json_name = "expr"];
  bool has_expr() const;
  private:
  bool _internal_has_expr() const;
  public:
  void clear_expr();
  const ::pg_query::Node& expr() const;
  ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* expr);
  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();
  public:
  void unsafe_arena_set_allocated_expr(
      ::pg_query::Node* expr);
  ::pg_query::Node* unsafe_arena_release_expr();

  // .pg_query.TypeName type_name = 3 [json_name = "typeName"];
  bool has_type_name() const;
  private:
  bool _internal_has_type_name() const;
  public:
  void clear_type_name();
  const ::pg_query::TypeName& type_name() const;
  ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* type_name);
  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();
  public:
  void unsafe_arena_set_allocated_type_name(
      ::pg_query::TypeName* type_name);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  // .pg_query.XmlOptionType xmloption = 1 [json_name = "xmloption"];
  void clear_xmloption();
  ::pg_query::XmlOptionType xmloption() const;
  void set_xmloption(::pg_query::XmlOptionType value);
  private:
  ::pg_query::XmlOptionType _internal_xmloption() const;
  void _internal_set_xmloption(::pg_query::XmlOptionType value);
  public:

  // int32 location = 4 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.XmlSerialize)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* expr_;
  ::pg_query::TypeName* type_name_;
  int xmloption_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class WithClause PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.WithClause) */ {
 public:
  inline WithClause() : WithClause(nullptr) {}
  virtual ~WithClause();

  WithClause(const WithClause& from);
  WithClause(WithClause&& from) noexcept
    : WithClause() {
    *this = ::std::move(from);
  }

  inline WithClause& operator=(const WithClause& from) {
    CopyFrom(from);
    return *this;
  }
  inline WithClause& operator=(WithClause&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const WithClause& default_instance();

  static inline const WithClause* internal_default_instance() {
    return reinterpret_cast<const WithClause*>(
               &_WithClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    218;

  friend void swap(WithClause& a, WithClause& b) {
    a.Swap(&b);
  }
  inline void Swap(WithClause* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(WithClause* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline WithClause* New() const final {
    return CreateMaybeMessage<WithClause>(nullptr);
  }

  WithClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WithClause>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WithClause& from);
  void MergeFrom(const WithClause& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WithClause* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.WithClause";
  }
  protected:
  explicit WithClause(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCtesFieldNumber = 1,
    kRecursiveFieldNumber = 2,
    kLocationFieldNumber = 3,
  };
  // repeated .pg_query.Node ctes = 1 [json_name = "ctes"];
  int ctes_size() const;
  private:
  int _internal_ctes_size() const;
  public:
  void clear_ctes();
  ::pg_query::Node* mutable_ctes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_ctes();
  private:
  const ::pg_query::Node& _internal_ctes(int index) const;
  ::pg_query::Node* _internal_add_ctes();
  public:
  const ::pg_query::Node& ctes(int index) const;
  ::pg_query::Node* add_ctes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      ctes() const;

  // bool recursive = 2 [json_name = "recursive"];
  void clear_recursive();
  bool recursive() const;
  void set_recursive(bool value);
  private:
  bool _internal_recursive() const;
  void _internal_set_recursive(bool value);
  public:

  // int32 location = 3 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.WithClause)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ctes_;
  bool recursive_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class InferClause PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.InferClause) */ {
 public:
  inline InferClause() : InferClause(nullptr) {}
  virtual ~InferClause();

  InferClause(const InferClause& from);
  InferClause(InferClause&& from) noexcept
    : InferClause() {
    *this = ::std::move(from);
  }

  inline InferClause& operator=(const InferClause& from) {
    CopyFrom(from);
    return *this;
  }
  inline InferClause& operator=(InferClause&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const InferClause& default_instance();

  static inline const InferClause* internal_default_instance() {
    return reinterpret_cast<const InferClause*>(
               &_InferClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    219;

  friend void swap(InferClause& a, InferClause& b) {
    a.Swap(&b);
  }
  inline void Swap(InferClause* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InferClause* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline InferClause* New() const final {
    return CreateMaybeMessage<InferClause>(nullptr);
  }

  InferClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<InferClause>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const InferClause& from);
  void MergeFrom(const InferClause& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InferClause* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.InferClause";
  }
  protected:
  explicit InferClause(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIndexElemsFieldNumber = 1,
    kConnameFieldNumber = 3,
    kWhereClauseFieldNumber = 2,
    kLocationFieldNumber = 4,
  };
  // repeated .pg_query.Node index_elems = 1 [json_name = "indexElems"];
  int index_elems_size() const;
  private:
  int _internal_index_elems_size() const;
  public:
  void clear_index_elems();
  ::pg_query::Node* mutable_index_elems(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_index_elems();
  private:
  const ::pg_query::Node& _internal_index_elems(int index) const;
  ::pg_query::Node* _internal_add_index_elems();
  public:
  const ::pg_query::Node& index_elems(int index) const;
  ::pg_query::Node* add_index_elems();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      index_elems() const;

  // string conname = 3 [json_name = "conname"];
  void clear_conname();
  const std::string& conname() const;
  void set_conname(const std::string& value);
  void set_conname(std::string&& value);
  void set_conname(const char* value);
  void set_conname(const char* value, size_t size);
  std::string* mutable_conname();
  std::string* release_conname();
  void set_allocated_conname(std::string* conname);
  private:
  const std::string& _internal_conname() const;
  void _internal_set_conname(const std::string& value);
  std::string* _internal_mutable_conname();
  public:

  // .pg_query.Node where_clause = 2 [json_name = "whereClause"];
  bool has_where_clause() const;
  private:
  bool _internal_has_where_clause() const;
  public:
  void clear_where_clause();
  const ::pg_query::Node& where_clause() const;
  ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* where_clause);
  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();
  public:
  void unsafe_arena_set_allocated_where_clause(
      ::pg_query::Node* where_clause);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  // int32 location = 4 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.InferClause)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > index_elems_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conname_;
  ::pg_query::Node* where_clause_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class OnConflictClause PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.OnConflictClause) */ {
 public:
  inline OnConflictClause() : OnConflictClause(nullptr) {}
  virtual ~OnConflictClause();

  OnConflictClause(const OnConflictClause& from);
  OnConflictClause(OnConflictClause&& from) noexcept
    : OnConflictClause() {
    *this = ::std::move(from);
  }

  inline OnConflictClause& operator=(const OnConflictClause& from) {
    CopyFrom(from);
    return *this;
  }
  inline OnConflictClause& operator=(OnConflictClause&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const OnConflictClause& default_instance();

  static inline const OnConflictClause* internal_default_instance() {
    return reinterpret_cast<const OnConflictClause*>(
               &_OnConflictClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    220;

  friend void swap(OnConflictClause& a, OnConflictClause& b) {
    a.Swap(&b);
  }
  inline void Swap(OnConflictClause* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OnConflictClause* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline OnConflictClause* New() const final {
    return CreateMaybeMessage<OnConflictClause>(nullptr);
  }

  OnConflictClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<OnConflictClause>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const OnConflictClause& from);
  void MergeFrom(const OnConflictClause& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OnConflictClause* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.OnConflictClause";
  }
  protected:
  explicit OnConflictClause(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTargetListFieldNumber = 3,
    kInferFieldNumber = 2,
    kWhereClauseFieldNumber = 4,
    kActionFieldNumber = 1,
    kLocationFieldNumber = 5,
  };
  // repeated .pg_query.Node target_list = 3 [json_name = "targetList"];
  int target_list_size() const;
  private:
  int _internal_target_list_size() const;
  public:
  void clear_target_list();
  ::pg_query::Node* mutable_target_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_target_list();
  private:
  const ::pg_query::Node& _internal_target_list(int index) const;
  ::pg_query::Node* _internal_add_target_list();
  public:
  const ::pg_query::Node& target_list(int index) const;
  ::pg_query::Node* add_target_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      target_list() const;

  // .pg_query.InferClause infer = 2 [json_name = "infer"];
  bool has_infer() const;
  private:
  bool _internal_has_infer() const;
  public:
  void clear_infer();
  const ::pg_query::InferClause& infer() const;
  ::pg_query::InferClause* release_infer();
  ::pg_query::InferClause* mutable_infer();
  void set_allocated_infer(::pg_query::InferClause* infer);
  private:
  const ::pg_query::InferClause& _internal_infer() const;
  ::pg_query::InferClause* _internal_mutable_infer();
  public:
  void unsafe_arena_set_allocated_infer(
      ::pg_query::InferClause* infer);
  ::pg_query::InferClause* unsafe_arena_release_infer();

  // .pg_query.Node where_clause = 4 [json_name = "whereClause"];
  bool has_where_clause() const;
  private:
  bool _internal_has_where_clause() const;
  public:
  void clear_where_clause();
  const ::pg_query::Node& where_clause() const;
  ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* where_clause);
  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();
  public:
  void unsafe_arena_set_allocated_where_clause(
      ::pg_query::Node* where_clause);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  // .pg_query.OnConflictAction action = 1 [json_name = "action"];
  void clear_action();
  ::pg_query::OnConflictAction action() const;
  void set_action(::pg_query::OnConflictAction value);
  private:
  ::pg_query::OnConflictAction _internal_action() const;
  void _internal_set_action(::pg_query::OnConflictAction value);
  public:

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.OnConflictClause)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > target_list_;
  ::pg_query::InferClause* infer_;
  ::pg_query::Node* where_clause_;
  int action_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CommonTableExpr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CommonTableExpr) */ {
 public:
  inline CommonTableExpr() : CommonTableExpr(nullptr) {}
  virtual ~CommonTableExpr();

  CommonTableExpr(const CommonTableExpr& from);
  CommonTableExpr(CommonTableExpr&& from) noexcept
    : CommonTableExpr() {
    *this = ::std::move(from);
  }

  inline CommonTableExpr& operator=(const CommonTableExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline CommonTableExpr& operator=(CommonTableExpr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CommonTableExpr& default_instance();

  static inline const CommonTableExpr* internal_default_instance() {
    return reinterpret_cast<const CommonTableExpr*>(
               &_CommonTableExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    221;

  friend void swap(CommonTableExpr& a, CommonTableExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(CommonTableExpr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CommonTableExpr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CommonTableExpr* New() const final {
    return CreateMaybeMessage<CommonTableExpr>(nullptr);
  }

  CommonTableExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CommonTableExpr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CommonTableExpr& from);
  void MergeFrom(const CommonTableExpr& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CommonTableExpr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CommonTableExpr";
  }
  protected:
  explicit CommonTableExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAliascolnamesFieldNumber = 2,
    kCtecolnamesFieldNumber = 8,
    kCtecoltypesFieldNumber = 9,
    kCtecoltypmodsFieldNumber = 10,
    kCtecolcollationsFieldNumber = 11,
    kCtenameFieldNumber = 1,
    kCtequeryFieldNumber = 4,
    kCtematerializedFieldNumber = 3,
    kLocationFieldNumber = 5,
    kCterecursiveFieldNumber = 6,
    kCterefcountFieldNumber = 7,
  };
  // repeated .pg_query.Node aliascolnames = 2 [json_name = "aliascolnames"];
  int aliascolnames_size() const;
  private:
  int _internal_aliascolnames_size() const;
  public:
  void clear_aliascolnames();
  ::pg_query::Node* mutable_aliascolnames(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_aliascolnames();
  private:
  const ::pg_query::Node& _internal_aliascolnames(int index) const;
  ::pg_query::Node* _internal_add_aliascolnames();
  public:
  const ::pg_query::Node& aliascolnames(int index) const;
  ::pg_query::Node* add_aliascolnames();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      aliascolnames() const;

  // repeated .pg_query.Node ctecolnames = 8 [json_name = "ctecolnames"];
  int ctecolnames_size() const;
  private:
  int _internal_ctecolnames_size() const;
  public:
  void clear_ctecolnames();
  ::pg_query::Node* mutable_ctecolnames(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_ctecolnames();
  private:
  const ::pg_query::Node& _internal_ctecolnames(int index) const;
  ::pg_query::Node* _internal_add_ctecolnames();
  public:
  const ::pg_query::Node& ctecolnames(int index) const;
  ::pg_query::Node* add_ctecolnames();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      ctecolnames() const;

  // repeated .pg_query.Node ctecoltypes = 9 [json_name = "ctecoltypes"];
  int ctecoltypes_size() const;
  private:
  int _internal_ctecoltypes_size() const;
  public:
  void clear_ctecoltypes();
  ::pg_query::Node* mutable_ctecoltypes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_ctecoltypes();
  private:
  const ::pg_query::Node& _internal_ctecoltypes(int index) const;
  ::pg_query::Node* _internal_add_ctecoltypes();
  public:
  const ::pg_query::Node& ctecoltypes(int index) const;
  ::pg_query::Node* add_ctecoltypes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      ctecoltypes() const;

  // repeated .pg_query.Node ctecoltypmods = 10 [json_name = "ctecoltypmods"];
  int ctecoltypmods_size() const;
  private:
  int _internal_ctecoltypmods_size() const;
  public:
  void clear_ctecoltypmods();
  ::pg_query::Node* mutable_ctecoltypmods(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_ctecoltypmods();
  private:
  const ::pg_query::Node& _internal_ctecoltypmods(int index) const;
  ::pg_query::Node* _internal_add_ctecoltypmods();
  public:
  const ::pg_query::Node& ctecoltypmods(int index) const;
  ::pg_query::Node* add_ctecoltypmods();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      ctecoltypmods() const;

  // repeated .pg_query.Node ctecolcollations = 11 [json_name = "ctecolcollations"];
  int ctecolcollations_size() const;
  private:
  int _internal_ctecolcollations_size() const;
  public:
  void clear_ctecolcollations();
  ::pg_query::Node* mutable_ctecolcollations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_ctecolcollations();
  private:
  const ::pg_query::Node& _internal_ctecolcollations(int index) const;
  ::pg_query::Node* _internal_add_ctecolcollations();
  public:
  const ::pg_query::Node& ctecolcollations(int index) const;
  ::pg_query::Node* add_ctecolcollations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      ctecolcollations() const;

  // string ctename = 1 [json_name = "ctename"];
  void clear_ctename();
  const std::string& ctename() const;
  void set_ctename(const std::string& value);
  void set_ctename(std::string&& value);
  void set_ctename(const char* value);
  void set_ctename(const char* value, size_t size);
  std::string* mutable_ctename();
  std::string* release_ctename();
  void set_allocated_ctename(std::string* ctename);
  private:
  const std::string& _internal_ctename() const;
  void _internal_set_ctename(const std::string& value);
  std::string* _internal_mutable_ctename();
  public:

  // .pg_query.Node ctequery = 4 [json_name = "ctequery"];
  bool has_ctequery() const;
  private:
  bool _internal_has_ctequery() const;
  public:
  void clear_ctequery();
  const ::pg_query::Node& ctequery() const;
  ::pg_query::Node* release_ctequery();
  ::pg_query::Node* mutable_ctequery();
  void set_allocated_ctequery(::pg_query::Node* ctequery);
  private:
  const ::pg_query::Node& _internal_ctequery() const;
  ::pg_query::Node* _internal_mutable_ctequery();
  public:
  void unsafe_arena_set_allocated_ctequery(
      ::pg_query::Node* ctequery);
  ::pg_query::Node* unsafe_arena_release_ctequery();

  // .pg_query.CTEMaterialize ctematerialized = 3 [json_name = "ctematerialized"];
  void clear_ctematerialized();
  ::pg_query::CTEMaterialize ctematerialized() const;
  void set_ctematerialized(::pg_query::CTEMaterialize value);
  private:
  ::pg_query::CTEMaterialize _internal_ctematerialized() const;
  void _internal_set_ctematerialized(::pg_query::CTEMaterialize value);
  public:

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool cterecursive = 6 [json_name = "cterecursive"];
  void clear_cterecursive();
  bool cterecursive() const;
  void set_cterecursive(bool value);
  private:
  bool _internal_cterecursive() const;
  void _internal_set_cterecursive(bool value);
  public:

  // int32 cterefcount = 7 [json_name = "cterefcount"];
  void clear_cterefcount();
  ::PROTOBUF_NAMESPACE_ID::int32 cterefcount() const;
  void set_cterefcount(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cterefcount() const;
  void _internal_set_cterefcount(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CommonTableExpr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > aliascolnames_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ctecolnames_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ctecoltypes_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ctecoltypmods_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ctecolcollations_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ctename_;
  ::pg_query::Node* ctequery_;
  int ctematerialized_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  bool cterecursive_;
  ::PROTOBUF_NAMESPACE_ID::int32 cterefcount_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class RoleSpec PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RoleSpec) */ {
 public:
  inline RoleSpec() : RoleSpec(nullptr) {}
  virtual ~RoleSpec();

  RoleSpec(const RoleSpec& from);
  RoleSpec(RoleSpec&& from) noexcept
    : RoleSpec() {
    *this = ::std::move(from);
  }

  inline RoleSpec& operator=(const RoleSpec& from) {
    CopyFrom(from);
    return *this;
  }
  inline RoleSpec& operator=(RoleSpec&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RoleSpec& default_instance();

  static inline const RoleSpec* internal_default_instance() {
    return reinterpret_cast<const RoleSpec*>(
               &_RoleSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    222;

  friend void swap(RoleSpec& a, RoleSpec& b) {
    a.Swap(&b);
  }
  inline void Swap(RoleSpec* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RoleSpec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RoleSpec* New() const final {
    return CreateMaybeMessage<RoleSpec>(nullptr);
  }

  RoleSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RoleSpec>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RoleSpec& from);
  void MergeFrom(const RoleSpec& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RoleSpec* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.RoleSpec";
  }
  protected:
  explicit RoleSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRolenameFieldNumber = 2,
    kRoletypeFieldNumber = 1,
    kLocationFieldNumber = 3,
  };
  // string rolename = 2 [json_name = "rolename"];
  void clear_rolename();
  const std::string& rolename() const;
  void set_rolename(const std::string& value);
  void set_rolename(std::string&& value);
  void set_rolename(const char* value);
  void set_rolename(const char* value, size_t size);
  std::string* mutable_rolename();
  std::string* release_rolename();
  void set_allocated_rolename(std::string* rolename);
  private:
  const std::string& _internal_rolename() const;
  void _internal_set_rolename(const std::string& value);
  std::string* _internal_mutable_rolename();
  public:

  // .pg_query.RoleSpecType roletype = 1 [json_name = "roletype"];
  void clear_roletype();
  ::pg_query::RoleSpecType roletype() const;
  void set_roletype(::pg_query::RoleSpecType value);
  private:
  ::pg_query::RoleSpecType _internal_roletype() const;
  void _internal_set_roletype(::pg_query::RoleSpecType value);
  public:

  // int32 location = 3 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.RoleSpec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rolename_;
  int roletype_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class TriggerTransition PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TriggerTransition) */ {
 public:
  inline TriggerTransition() : TriggerTransition(nullptr) {}
  virtual ~TriggerTransition();

  TriggerTransition(const TriggerTransition& from);
  TriggerTransition(TriggerTransition&& from) noexcept
    : TriggerTransition() {
    *this = ::std::move(from);
  }

  inline TriggerTransition& operator=(const TriggerTransition& from) {
    CopyFrom(from);
    return *this;
  }
  inline TriggerTransition& operator=(TriggerTransition&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TriggerTransition& default_instance();

  static inline const TriggerTransition* internal_default_instance() {
    return reinterpret_cast<const TriggerTransition*>(
               &_TriggerTransition_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    223;

  friend void swap(TriggerTransition& a, TriggerTransition& b) {
    a.Swap(&b);
  }
  inline void Swap(TriggerTransition* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TriggerTransition* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TriggerTransition* New() const final {
    return CreateMaybeMessage<TriggerTransition>(nullptr);
  }

  TriggerTransition* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TriggerTransition>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TriggerTransition& from);
  void MergeFrom(const TriggerTransition& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TriggerTransition* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.TriggerTransition";
  }
  protected:
  explicit TriggerTransition(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kIsNewFieldNumber = 2,
    kIsTableFieldNumber = 3,
  };
  // string name = 1 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // bool is_new = 2 [json_name = "isNew"];
  void clear_is_new();
  bool is_new() const;
  void set_is_new(bool value);
  private:
  bool _internal_is_new() const;
  void _internal_set_is_new(bool value);
  public:

  // bool is_table = 3 [json_name = "isTable"];
  void clear_is_table();
  bool is_table() const;
  void set_is_table(bool value);
  private:
  bool _internal_is_table() const;
  void _internal_set_is_table(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.TriggerTransition)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  bool is_new_;
  bool is_table_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class PartitionElem PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionElem) */ {
 public:
  inline PartitionElem() : PartitionElem(nullptr) {}
  virtual ~PartitionElem();

  PartitionElem(const PartitionElem& from);
  PartitionElem(PartitionElem&& from) noexcept
    : PartitionElem() {
    *this = ::std::move(from);
  }

  inline PartitionElem& operator=(const PartitionElem& from) {
    CopyFrom(from);
    return *this;
  }
  inline PartitionElem& operator=(PartitionElem&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PartitionElem& default_instance();

  static inline const PartitionElem* internal_default_instance() {
    return reinterpret_cast<const PartitionElem*>(
               &_PartitionElem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    224;

  friend void swap(PartitionElem& a, PartitionElem& b) {
    a.Swap(&b);
  }
  inline void Swap(PartitionElem* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PartitionElem* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PartitionElem* New() const final {
    return CreateMaybeMessage<PartitionElem>(nullptr);
  }

  PartitionElem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PartitionElem>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PartitionElem& from);
  void MergeFrom(const PartitionElem& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PartitionElem* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.PartitionElem";
  }
  protected:
  explicit PartitionElem(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCollationFieldNumber = 3,
    kOpclassFieldNumber = 4,
    kNameFieldNumber = 1,
    kExprFieldNumber = 2,
    kLocationFieldNumber = 5,
  };
  // repeated .pg_query.Node collation = 3 [json_name = "collation"];
  int collation_size() const;
  private:
  int _internal_collation_size() const;
  public:
  void clear_collation();
  ::pg_query::Node* mutable_collation(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_collation();
  private:
  const ::pg_query::Node& _internal_collation(int index) const;
  ::pg_query::Node* _internal_add_collation();
  public:
  const ::pg_query::Node& collation(int index) const;
  ::pg_query::Node* add_collation();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      collation() const;

  // repeated .pg_query.Node opclass = 4 [json_name = "opclass"];
  int opclass_size() const;
  private:
  int _internal_opclass_size() const;
  public:
  void clear_opclass();
  ::pg_query::Node* mutable_opclass(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_opclass();
  private:
  const ::pg_query::Node& _internal_opclass(int index) const;
  ::pg_query::Node* _internal_add_opclass();
  public:
  const ::pg_query::Node& opclass(int index) const;
  ::pg_query::Node* add_opclass();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      opclass() const;

  // string name = 1 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .pg_query.Node expr = 2 [json_name = "expr"];
  bool has_expr() const;
  private:
  bool _internal_has_expr() const;
  public:
  void clear_expr();
  const ::pg_query::Node& expr() const;
  ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* expr);
  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();
  public:
  void unsafe_arena_set_allocated_expr(
      ::pg_query::Node* expr);
  ::pg_query::Node* unsafe_arena_release_expr();

  // int32 location = 5 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.PartitionElem)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > collation_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opclass_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::pg_query::Node* expr_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class PartitionSpec PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionSpec) */ {
 public:
  inline PartitionSpec() : PartitionSpec(nullptr) {}
  virtual ~PartitionSpec();

  PartitionSpec(const PartitionSpec& from);
  PartitionSpec(PartitionSpec&& from) noexcept
    : PartitionSpec() {
    *this = ::std::move(from);
  }

  inline PartitionSpec& operator=(const PartitionSpec& from) {
    CopyFrom(from);
    return *this;
  }
  inline PartitionSpec& operator=(PartitionSpec&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PartitionSpec& default_instance();

  static inline const PartitionSpec* internal_default_instance() {
    return reinterpret_cast<const PartitionSpec*>(
               &_PartitionSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    225;

  friend void swap(PartitionSpec& a, PartitionSpec& b) {
    a.Swap(&b);
  }
  inline void Swap(PartitionSpec* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PartitionSpec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PartitionSpec* New() const final {
    return CreateMaybeMessage<PartitionSpec>(nullptr);
  }

  PartitionSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PartitionSpec>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PartitionSpec& from);
  void MergeFrom(const PartitionSpec& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PartitionSpec* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.PartitionSpec";
  }
  protected:
  explicit PartitionSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPartParamsFieldNumber = 2,
    kStrategyFieldNumber = 1,
    kLocationFieldNumber = 3,
  };
  // repeated .pg_query.Node part_params = 2 [json_name = "partParams"];
  int part_params_size() const;
  private:
  int _internal_part_params_size() const;
  public:
  void clear_part_params();
  ::pg_query::Node* mutable_part_params(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_part_params();
  private:
  const ::pg_query::Node& _internal_part_params(int index) const;
  ::pg_query::Node* _internal_add_part_params();
  public:
  const ::pg_query::Node& part_params(int index) const;
  ::pg_query::Node* add_part_params();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      part_params() const;

  // string strategy = 1 [json_name = "strategy"];
  void clear_strategy();
  const std::string& strategy() const;
  void set_strategy(const std::string& value);
  void set_strategy(std::string&& value);
  void set_strategy(const char* value);
  void set_strategy(const char* value, size_t size);
  std::string* mutable_strategy();
  std::string* release_strategy();
  void set_allocated_strategy(std::string* strategy);
  private:
  const std::string& _internal_strategy() const;
  void _internal_set_strategy(const std::string& value);
  std::string* _internal_mutable_strategy();
  public:

  // int32 location = 3 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.PartitionSpec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > part_params_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr strategy_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class PartitionBoundSpec PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionBoundSpec) */ {
 public:
  inline PartitionBoundSpec() : PartitionBoundSpec(nullptr) {}
  virtual ~PartitionBoundSpec();

  PartitionBoundSpec(const PartitionBoundSpec& from);
  PartitionBoundSpec(PartitionBoundSpec&& from) noexcept
    : PartitionBoundSpec() {
    *this = ::std::move(from);
  }

  inline PartitionBoundSpec& operator=(const PartitionBoundSpec& from) {
    CopyFrom(from);
    return *this;
  }
  inline PartitionBoundSpec& operator=(PartitionBoundSpec&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PartitionBoundSpec& default_instance();

  static inline const PartitionBoundSpec* internal_default_instance() {
    return reinterpret_cast<const PartitionBoundSpec*>(
               &_PartitionBoundSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    226;

  friend void swap(PartitionBoundSpec& a, PartitionBoundSpec& b) {
    a.Swap(&b);
  }
  inline void Swap(PartitionBoundSpec* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PartitionBoundSpec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PartitionBoundSpec* New() const final {
    return CreateMaybeMessage<PartitionBoundSpec>(nullptr);
  }

  PartitionBoundSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PartitionBoundSpec>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PartitionBoundSpec& from);
  void MergeFrom(const PartitionBoundSpec& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PartitionBoundSpec* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.PartitionBoundSpec";
  }
  protected:
  explicit PartitionBoundSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kListdatumsFieldNumber = 5,
    kLowerdatumsFieldNumber = 6,
    kUpperdatumsFieldNumber = 7,
    kStrategyFieldNumber = 1,
    kIsDefaultFieldNumber = 2,
    kModulusFieldNumber = 3,
    kRemainderFieldNumber = 4,
    kLocationFieldNumber = 8,
  };
  // repeated .pg_query.Node listdatums = 5 [json_name = "listdatums"];
  int listdatums_size() const;
  private:
  int _internal_listdatums_size() const;
  public:
  void clear_listdatums();
  ::pg_query::Node* mutable_listdatums(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_listdatums();
  private:
  const ::pg_query::Node& _internal_listdatums(int index) const;
  ::pg_query::Node* _internal_add_listdatums();
  public:
  const ::pg_query::Node& listdatums(int index) const;
  ::pg_query::Node* add_listdatums();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      listdatums() const;

  // repeated .pg_query.Node lowerdatums = 6 [json_name = "lowerdatums"];
  int lowerdatums_size() const;
  private:
  int _internal_lowerdatums_size() const;
  public:
  void clear_lowerdatums();
  ::pg_query::Node* mutable_lowerdatums(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_lowerdatums();
  private:
  const ::pg_query::Node& _internal_lowerdatums(int index) const;
  ::pg_query::Node* _internal_add_lowerdatums();
  public:
  const ::pg_query::Node& lowerdatums(int index) const;
  ::pg_query::Node* add_lowerdatums();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      lowerdatums() const;

  // repeated .pg_query.Node upperdatums = 7 [json_name = "upperdatums"];
  int upperdatums_size() const;
  private:
  int _internal_upperdatums_size() const;
  public:
  void clear_upperdatums();
  ::pg_query::Node* mutable_upperdatums(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_upperdatums();
  private:
  const ::pg_query::Node& _internal_upperdatums(int index) const;
  ::pg_query::Node* _internal_add_upperdatums();
  public:
  const ::pg_query::Node& upperdatums(int index) const;
  ::pg_query::Node* add_upperdatums();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      upperdatums() const;

  // string strategy = 1 [json_name = "strategy"];
  void clear_strategy();
  const std::string& strategy() const;
  void set_strategy(const std::string& value);
  void set_strategy(std::string&& value);
  void set_strategy(const char* value);
  void set_strategy(const char* value, size_t size);
  std::string* mutable_strategy();
  std::string* release_strategy();
  void set_allocated_strategy(std::string* strategy);
  private:
  const std::string& _internal_strategy() const;
  void _internal_set_strategy(const std::string& value);
  std::string* _internal_mutable_strategy();
  public:

  // bool is_default = 2 [json_name = "is_default"];
  void clear_is_default();
  bool is_default() const;
  void set_is_default(bool value);
  private:
  bool _internal_is_default() const;
  void _internal_set_is_default(bool value);
  public:

  // int32 modulus = 3 [json_name = "modulus"];
  void clear_modulus();
  ::PROTOBUF_NAMESPACE_ID::int32 modulus() const;
  void set_modulus(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_modulus() const;
  void _internal_set_modulus(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 remainder = 4 [json_name = "remainder"];
  void clear_remainder();
  ::PROTOBUF_NAMESPACE_ID::int32 remainder() const;
  void set_remainder(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_remainder() const;
  void _internal_set_remainder(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 location = 8 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.PartitionBoundSpec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > listdatums_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > lowerdatums_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > upperdatums_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr strategy_;
  bool is_default_;
  ::PROTOBUF_NAMESPACE_ID::int32 modulus_;
  ::PROTOBUF_NAMESPACE_ID::int32 remainder_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class PartitionRangeDatum PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionRangeDatum) */ {
 public:
  inline PartitionRangeDatum() : PartitionRangeDatum(nullptr) {}
  virtual ~PartitionRangeDatum();

  PartitionRangeDatum(const PartitionRangeDatum& from);
  PartitionRangeDatum(PartitionRangeDatum&& from) noexcept
    : PartitionRangeDatum() {
    *this = ::std::move(from);
  }

  inline PartitionRangeDatum& operator=(const PartitionRangeDatum& from) {
    CopyFrom(from);
    return *this;
  }
  inline PartitionRangeDatum& operator=(PartitionRangeDatum&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PartitionRangeDatum& default_instance();

  static inline const PartitionRangeDatum* internal_default_instance() {
    return reinterpret_cast<const PartitionRangeDatum*>(
               &_PartitionRangeDatum_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    227;

  friend void swap(PartitionRangeDatum& a, PartitionRangeDatum& b) {
    a.Swap(&b);
  }
  inline void Swap(PartitionRangeDatum* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PartitionRangeDatum* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PartitionRangeDatum* New() const final {
    return CreateMaybeMessage<PartitionRangeDatum>(nullptr);
  }

  PartitionRangeDatum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PartitionRangeDatum>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PartitionRangeDatum& from);
  void MergeFrom(const PartitionRangeDatum& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PartitionRangeDatum* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.PartitionRangeDatum";
  }
  protected:
  explicit PartitionRangeDatum(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValueFieldNumber = 2,
    kKindFieldNumber = 1,
    kLocationFieldNumber = 3,
  };
  // .pg_query.Node value = 2 [json_name = "value"];
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::pg_query::Node& value() const;
  ::pg_query::Node* release_value();
  ::pg_query::Node* mutable_value();
  void set_allocated_value(::pg_query::Node* value);
  private:
  const ::pg_query::Node& _internal_value() const;
  ::pg_query::Node* _internal_mutable_value();
  public:
  void unsafe_arena_set_allocated_value(
      ::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_value();

  // .pg_query.PartitionRangeDatumKind kind = 1 [json_name = "kind"];
  void clear_kind();
  ::pg_query::PartitionRangeDatumKind kind() const;
  void set_kind(::pg_query::PartitionRangeDatumKind value);
  private:
  ::pg_query::PartitionRangeDatumKind _internal_kind() const;
  void _internal_set_kind(::pg_query::PartitionRangeDatumKind value);
  public:

  // int32 location = 3 [json_name = "location"];
  void clear_location();
  ::PROTOBUF_NAMESPACE_ID::int32 location() const;
  void set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_location() const;
  void _internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.PartitionRangeDatum)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::Node* value_;
  int kind_;
  ::PROTOBUF_NAMESPACE_ID::int32 location_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class PartitionCmd PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionCmd) */ {
 public:
  inline PartitionCmd() : PartitionCmd(nullptr) {}
  virtual ~PartitionCmd();

  PartitionCmd(const PartitionCmd& from);
  PartitionCmd(PartitionCmd&& from) noexcept
    : PartitionCmd() {
    *this = ::std::move(from);
  }

  inline PartitionCmd& operator=(const PartitionCmd& from) {
    CopyFrom(from);
    return *this;
  }
  inline PartitionCmd& operator=(PartitionCmd&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PartitionCmd& default_instance();

  static inline const PartitionCmd* internal_default_instance() {
    return reinterpret_cast<const PartitionCmd*>(
               &_PartitionCmd_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    228;

  friend void swap(PartitionCmd& a, PartitionCmd& b) {
    a.Swap(&b);
  }
  inline void Swap(PartitionCmd* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PartitionCmd* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PartitionCmd* New() const final {
    return CreateMaybeMessage<PartitionCmd>(nullptr);
  }

  PartitionCmd* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PartitionCmd>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PartitionCmd& from);
  void MergeFrom(const PartitionCmd& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PartitionCmd* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.PartitionCmd";
  }
  protected:
  explicit PartitionCmd(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kBoundFieldNumber = 2,
  };
  // .pg_query.RangeVar name = 1 [json_name = "name"];
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const ::pg_query::RangeVar& name() const;
  ::pg_query::RangeVar* release_name();
  ::pg_query::RangeVar* mutable_name();
  void set_allocated_name(::pg_query::RangeVar* name);
  private:
  const ::pg_query::RangeVar& _internal_name() const;
  ::pg_query::RangeVar* _internal_mutable_name();
  public:
  void unsafe_arena_set_allocated_name(
      ::pg_query::RangeVar* name);
  ::pg_query::RangeVar* unsafe_arena_release_name();

  // .pg_query.PartitionBoundSpec bound = 2 [json_name = "bound"];
  bool has_bound() const;
  private:
  bool _internal_has_bound() const;
  public:
  void clear_bound();
  const ::pg_query::PartitionBoundSpec& bound() const;
  ::pg_query::PartitionBoundSpec* release_bound();
  ::pg_query::PartitionBoundSpec* mutable_bound();
  void set_allocated_bound(::pg_query::PartitionBoundSpec* bound);
  private:
  const ::pg_query::PartitionBoundSpec& _internal_bound() const;
  ::pg_query::PartitionBoundSpec* _internal_mutable_bound();
  public:
  void unsafe_arena_set_allocated_bound(
      ::pg_query::PartitionBoundSpec* bound);
  ::pg_query::PartitionBoundSpec* unsafe_arena_release_bound();

  // @@protoc_insertion_point(class_scope:pg_query.PartitionCmd)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pg_query::RangeVar* name_;
  ::pg_query::PartitionBoundSpec* bound_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class VacuumRelation PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.VacuumRelation) */ {
 public:
  inline VacuumRelation() : VacuumRelation(nullptr) {}
  virtual ~VacuumRelation();

  VacuumRelation(const VacuumRelation& from);
  VacuumRelation(VacuumRelation&& from) noexcept
    : VacuumRelation() {
    *this = ::std::move(from);
  }

  inline VacuumRelation& operator=(const VacuumRelation& from) {
    CopyFrom(from);
    return *this;
  }
  inline VacuumRelation& operator=(VacuumRelation&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const VacuumRelation& default_instance();

  static inline const VacuumRelation* internal_default_instance() {
    return reinterpret_cast<const VacuumRelation*>(
               &_VacuumRelation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    229;

  friend void swap(VacuumRelation& a, VacuumRelation& b) {
    a.Swap(&b);
  }
  inline void Swap(VacuumRelation* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VacuumRelation* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline VacuumRelation* New() const final {
    return CreateMaybeMessage<VacuumRelation>(nullptr);
  }

  VacuumRelation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VacuumRelation>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const VacuumRelation& from);
  void MergeFrom(const VacuumRelation& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(VacuumRelation* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.VacuumRelation";
  }
  protected:
  explicit VacuumRelation(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kVaColsFieldNumber = 3,
    kRelationFieldNumber = 1,
    kOidFieldNumber = 2,
  };
  // repeated .pg_query.Node va_cols = 3 [json_name = "va_cols"];
  int va_cols_size() const;
  private:
  int _internal_va_cols_size() const;
  public:
  void clear_va_cols();
  ::pg_query::Node* mutable_va_cols(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
      mutable_va_cols();
  private:
  const ::pg_query::Node& _internal_va_cols(int index) const;
  ::pg_query::Node* _internal_add_va_cols();
  public:
  const ::pg_query::Node& va_cols(int index) const;
  ::pg_query::Node* add_va_cols();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
      va_cols() const;

  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  private:
  bool _internal_has_relation() const;
  public:
  void clear_relation();
  const ::pg_query::RangeVar& relation() const;
  ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* relation);
  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();
  public:
  void unsafe_arena_set_allocated_relation(
      ::pg_query::RangeVar* relation);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  // uint32 oid = 2 [json_name = "oid"];
  void clear_oid();
  ::PROTOBUF_NAMESPACE_ID::uint32 oid() const;
  void set_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_oid() const;
  void _internal_set_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.VacuumRelation)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > va_cols_;
  ::pg_query::RangeVar* relation_;
  ::PROTOBUF_NAMESPACE_ID::uint32 oid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class InlineCodeBlock PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.InlineCodeBlock) */ {
 public:
  inline InlineCodeBlock() : InlineCodeBlock(nullptr) {}
  virtual ~InlineCodeBlock();

  InlineCodeBlock(const InlineCodeBlock& from);
  InlineCodeBlock(InlineCodeBlock&& from) noexcept
    : InlineCodeBlock() {
    *this = ::std::move(from);
  }

  inline InlineCodeBlock& operator=(const InlineCodeBlock& from) {
    CopyFrom(from);
    return *this;
  }
  inline InlineCodeBlock& operator=(InlineCodeBlock&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const InlineCodeBlock& default_instance();

  static inline const InlineCodeBlock* internal_default_instance() {
    return reinterpret_cast<const InlineCodeBlock*>(
               &_InlineCodeBlock_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    230;

  friend void swap(InlineCodeBlock& a, InlineCodeBlock& b) {
    a.Swap(&b);
  }
  inline void Swap(InlineCodeBlock* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InlineCodeBlock* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline InlineCodeBlock* New() const final {
    return CreateMaybeMessage<InlineCodeBlock>(nullptr);
  }

  InlineCodeBlock* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<InlineCodeBlock>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const InlineCodeBlock& from);
  void MergeFrom(const InlineCodeBlock& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InlineCodeBlock* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.InlineCodeBlock";
  }
  protected:
  explicit InlineCodeBlock(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSourceTextFieldNumber = 1,
    kLangOidFieldNumber = 2,
    kLangIsTrustedFieldNumber = 3,
    kAtomicFieldNumber = 4,
  };
  // string source_text = 1 [json_name = "source_text"];
  void clear_source_text();
  const std::string& source_text() const;
  void set_source_text(const std::string& value);
  void set_source_text(std::string&& value);
  void set_source_text(const char* value);
  void set_source_text(const char* value, size_t size);
  std::string* mutable_source_text();
  std::string* release_source_text();
  void set_allocated_source_text(std::string* source_text);
  private:
  const std::string& _internal_source_text() const;
  void _internal_set_source_text(const std::string& value);
  std::string* _internal_mutable_source_text();
  public:

  // uint32 lang_oid = 2 [json_name = "langOid"];
  void clear_lang_oid();
  ::PROTOBUF_NAMESPACE_ID::uint32 lang_oid() const;
  void set_lang_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_lang_oid() const;
  void _internal_set_lang_oid(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool lang_is_trusted = 3 [json_name = "langIsTrusted"];
  void clear_lang_is_trusted();
  bool lang_is_trusted() const;
  void set_lang_is_trusted(bool value);
  private:
  bool _internal_lang_is_trusted() const;
  void _internal_set_lang_is_trusted(bool value);
  public:

  // bool atomic = 4 [json_name = "atomic"];
  void clear_atomic();
  bool atomic() const;
  void set_atomic(bool value);
  private:
  bool _internal_atomic() const;
  void _internal_set_atomic(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.InlineCodeBlock)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_text_;
  ::PROTOBUF_NAMESPACE_ID::uint32 lang_oid_;
  bool lang_is_trusted_;
  bool atomic_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class CallContext PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CallContext) */ {
 public:
  inline CallContext() : CallContext(nullptr) {}
  virtual ~CallContext();

  CallContext(const CallContext& from);
  CallContext(CallContext&& from) noexcept
    : CallContext() {
    *this = ::std::move(from);
  }

  inline CallContext& operator=(const CallContext& from) {
    CopyFrom(from);
    return *this;
  }
  inline CallContext& operator=(CallContext&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CallContext& default_instance();

  static inline const CallContext* internal_default_instance() {
    return reinterpret_cast<const CallContext*>(
               &_CallContext_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    231;

  friend void swap(CallContext& a, CallContext& b) {
    a.Swap(&b);
  }
  inline void Swap(CallContext* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CallContext* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CallContext* New() const final {
    return CreateMaybeMessage<CallContext>(nullptr);
  }

  CallContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CallContext>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CallContext& from);
  void MergeFrom(const CallContext& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CallContext* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.CallContext";
  }
  protected:
  explicit CallContext(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAtomicFieldNumber = 1,
  };
  // bool atomic = 1 [json_name = "atomic"];
  void clear_atomic();
  bool atomic() const;
  void set_atomic(bool value);
  private:
  bool _internal_atomic() const;
  void _internal_set_atomic(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.CallContext)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  bool atomic_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// -------------------------------------------------------------------

class ScanToken PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ScanToken) */ {
 public:
  inline ScanToken() : ScanToken(nullptr) {}
  virtual ~ScanToken();

  ScanToken(const ScanToken& from);
  ScanToken(ScanToken&& from) noexcept
    : ScanToken() {
    *this = ::std::move(from);
  }

  inline ScanToken& operator=(const ScanToken& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScanToken& operator=(ScanToken&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ScanToken& default_instance();

  static inline const ScanToken* internal_default_instance() {
    return reinterpret_cast<const ScanToken*>(
               &_ScanToken_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    232;

  friend void swap(ScanToken& a, ScanToken& b) {
    a.Swap(&b);
  }
  inline void Swap(ScanToken* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScanToken* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ScanToken* New() const final {
    return CreateMaybeMessage<ScanToken>(nullptr);
  }

  ScanToken* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ScanToken>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ScanToken& from);
  void MergeFrom(const ScanToken& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ScanToken* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pg_query.ScanToken";
  }
  protected:
  explicit ScanToken(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protobuf_2fpg_5fquery_2eproto);
    return ::descriptor_table_protobuf_2fpg_5fquery_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kStartFieldNumber = 1,
    kEndFieldNumber = 2,
    kTokenFieldNumber = 4,
    kKeywordKindFieldNumber = 5,
  };
  // int32 start = 1;
  void clear_start();
  ::PROTOBUF_NAMESPACE_ID::int32 start() const;
  void set_start(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_start() const;
  void _internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 end = 2;
  void clear_end();
  ::PROTOBUF_NAMESPACE_ID::int32 end() const;
  void set_end(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_end() const;
  void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // .pg_query.Token token = 4;
  void clear_token();
  ::pg_query::Token token() const;
  void set_token(::pg_query::Token value);
  private:
  ::pg_query::Token _internal_token() const;
  void _internal_set_token(::pg_query::Token value);
  public:

  // .pg_query.KeywordKind keyword_kind = 5;
  void clear_keyword_kind();
  ::pg_query::KeywordKind keyword_kind() const;
  void set_keyword_kind(::pg_query::KeywordKind value);
  private:
  ::pg_query::KeywordKind _internal_keyword_kind() const;
  void _internal_set_keyword_kind(::pg_query::KeywordKind value);
  public:

  // @@protoc_insertion_point(class_scope:pg_query.ScanToken)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int32 start_;
  ::PROTOBUF_NAMESPACE_ID::int32 end_;
  int token_;
  int keyword_kind_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// ParseResult

// int32 version = 1;
inline void ParseResult::clear_version() {
  version_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ParseResult::_internal_version() const {
  return version_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ParseResult::version() const {
  // @@protoc_insertion_point(field_get:pg_query.ParseResult.version)
  return _internal_version();
}
inline void ParseResult::_internal_set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  version_ = value;
}
inline void ParseResult::set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:pg_query.ParseResult.version)
}

// repeated .pg_query.RawStmt stmts = 2;
inline int ParseResult::_internal_stmts_size() const {
  return stmts_.size();
}
inline int ParseResult::stmts_size() const {
  return _internal_stmts_size();
}
inline void ParseResult::clear_stmts() {
  stmts_.Clear();
}
inline ::pg_query::RawStmt* ParseResult::mutable_stmts(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ParseResult.stmts)
  return stmts_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::RawStmt >*
ParseResult::mutable_stmts() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ParseResult.stmts)
  return &stmts_;
}
inline const ::pg_query::RawStmt& ParseResult::_internal_stmts(int index) const {
  return stmts_.Get(index);
}
inline const ::pg_query::RawStmt& ParseResult::stmts(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ParseResult.stmts)
  return _internal_stmts(index);
}
inline ::pg_query::RawStmt* ParseResult::_internal_add_stmts() {
  return stmts_.Add();
}
inline ::pg_query::RawStmt* ParseResult::add_stmts() {
  // @@protoc_insertion_point(field_add:pg_query.ParseResult.stmts)
  return _internal_add_stmts();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::RawStmt >&
ParseResult::stmts() const {
  // @@protoc_insertion_point(field_list:pg_query.ParseResult.stmts)
  return stmts_;
}

// -------------------------------------------------------------------

// ScanResult

// int32 version = 1;
inline void ScanResult::clear_version() {
  version_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ScanResult::_internal_version() const {
  return version_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ScanResult::version() const {
  // @@protoc_insertion_point(field_get:pg_query.ScanResult.version)
  return _internal_version();
}
inline void ScanResult::_internal_set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  version_ = value;
}
inline void ScanResult::set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:pg_query.ScanResult.version)
}

// repeated .pg_query.ScanToken tokens = 2;
inline int ScanResult::_internal_tokens_size() const {
  return tokens_.size();
}
inline int ScanResult::tokens_size() const {
  return _internal_tokens_size();
}
inline void ScanResult::clear_tokens() {
  tokens_.Clear();
}
inline ::pg_query::ScanToken* ScanResult::mutable_tokens(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ScanResult.tokens)
  return tokens_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::ScanToken >*
ScanResult::mutable_tokens() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ScanResult.tokens)
  return &tokens_;
}
inline const ::pg_query::ScanToken& ScanResult::_internal_tokens(int index) const {
  return tokens_.Get(index);
}
inline const ::pg_query::ScanToken& ScanResult::tokens(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ScanResult.tokens)
  return _internal_tokens(index);
}
inline ::pg_query::ScanToken* ScanResult::_internal_add_tokens() {
  return tokens_.Add();
}
inline ::pg_query::ScanToken* ScanResult::add_tokens() {
  // @@protoc_insertion_point(field_add:pg_query.ScanResult.tokens)
  return _internal_add_tokens();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::ScanToken >&
ScanResult::tokens() const {
  // @@protoc_insertion_point(field_list:pg_query.ScanResult.tokens)
  return tokens_;
}

// -------------------------------------------------------------------

// Node

// .pg_query.Alias alias = 1 [json_name = "Alias"];
inline bool Node::_internal_has_alias() const {
  return node_case() == kAlias;
}
inline bool Node::has_alias() const {
  return _internal_has_alias();
}
inline void Node::set_has_alias() {
  _oneof_case_[0] = kAlias;
}
inline void Node::clear_alias() {
  if (_internal_has_alias()) {
    if (GetArena() == nullptr) {
      delete node_.alias_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Alias* Node::release_alias() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alias)
  if (_internal_has_alias()) {
    clear_has_node();
      ::pg_query::Alias* temp = node_.alias_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alias_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Alias& Node::_internal_alias() const {
  return _internal_has_alias()
      ? *node_.alias_
      : reinterpret_cast< ::pg_query::Alias&>(::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& Node::alias() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alias)
  return _internal_alias();
}
inline ::pg_query::Alias* Node::unsafe_arena_release_alias() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alias)
  if (_internal_has_alias()) {
    clear_has_node();
    ::pg_query::Alias* temp = node_.alias_;
    node_.alias_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alias(::pg_query::Alias* alias) {
  clear_node();
  if (alias) {
    set_has_alias();
    node_.alias_ = alias;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alias)
}
inline ::pg_query::Alias* Node::_internal_mutable_alias() {
  if (!_internal_has_alias()) {
    clear_node();
    set_has_alias();
    node_.alias_ = CreateMaybeMessage< ::pg_query::Alias >(GetArena());
  }
  return node_.alias_;
}
inline ::pg_query::Alias* Node::mutable_alias() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alias)
  return _internal_mutable_alias();
}

// .pg_query.RangeVar range_var = 2 [json_name = "RangeVar"];
inline bool Node::_internal_has_range_var() const {
  return node_case() == kRangeVar;
}
inline bool Node::has_range_var() const {
  return _internal_has_range_var();
}
inline void Node::set_has_range_var() {
  _oneof_case_[0] = kRangeVar;
}
inline void Node::clear_range_var() {
  if (_internal_has_range_var()) {
    if (GetArena() == nullptr) {
      delete node_.range_var_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RangeVar* Node::release_range_var() {
  // @@protoc_insertion_point(field_release:pg_query.Node.range_var)
  if (_internal_has_range_var()) {
    clear_has_node();
      ::pg_query::RangeVar* temp = node_.range_var_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.range_var_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeVar& Node::_internal_range_var() const {
  return _internal_has_range_var()
      ? *node_.range_var_
      : reinterpret_cast< ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& Node::range_var() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.range_var)
  return _internal_range_var();
}
inline ::pg_query::RangeVar* Node::unsafe_arena_release_range_var() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_var)
  if (_internal_has_range_var()) {
    clear_has_node();
    ::pg_query::RangeVar* temp = node_.range_var_;
    node_.range_var_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_var(::pg_query::RangeVar* range_var) {
  clear_node();
  if (range_var) {
    set_has_range_var();
    node_.range_var_ = range_var;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_var)
}
inline ::pg_query::RangeVar* Node::_internal_mutable_range_var() {
  if (!_internal_has_range_var()) {
    clear_node();
    set_has_range_var();
    node_.range_var_ = CreateMaybeMessage< ::pg_query::RangeVar >(GetArena());
  }
  return node_.range_var_;
}
inline ::pg_query::RangeVar* Node::mutable_range_var() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_var)
  return _internal_mutable_range_var();
}

// .pg_query.TableFunc table_func = 3 [json_name = "TableFunc"];
inline bool Node::_internal_has_table_func() const {
  return node_case() == kTableFunc;
}
inline bool Node::has_table_func() const {
  return _internal_has_table_func();
}
inline void Node::set_has_table_func() {
  _oneof_case_[0] = kTableFunc;
}
inline void Node::clear_table_func() {
  if (_internal_has_table_func()) {
    if (GetArena() == nullptr) {
      delete node_.table_func_;
    }
    clear_has_node();
  }
}
inline ::pg_query::TableFunc* Node::release_table_func() {
  // @@protoc_insertion_point(field_release:pg_query.Node.table_func)
  if (_internal_has_table_func()) {
    clear_has_node();
      ::pg_query::TableFunc* temp = node_.table_func_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.table_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TableFunc& Node::_internal_table_func() const {
  return _internal_has_table_func()
      ? *node_.table_func_
      : reinterpret_cast< ::pg_query::TableFunc&>(::pg_query::_TableFunc_default_instance_);
}
inline const ::pg_query::TableFunc& Node::table_func() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.table_func)
  return _internal_table_func();
}
inline ::pg_query::TableFunc* Node::unsafe_arena_release_table_func() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.table_func)
  if (_internal_has_table_func()) {
    clear_has_node();
    ::pg_query::TableFunc* temp = node_.table_func_;
    node_.table_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_table_func(::pg_query::TableFunc* table_func) {
  clear_node();
  if (table_func) {
    set_has_table_func();
    node_.table_func_ = table_func;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.table_func)
}
inline ::pg_query::TableFunc* Node::_internal_mutable_table_func() {
  if (!_internal_has_table_func()) {
    clear_node();
    set_has_table_func();
    node_.table_func_ = CreateMaybeMessage< ::pg_query::TableFunc >(GetArena());
  }
  return node_.table_func_;
}
inline ::pg_query::TableFunc* Node::mutable_table_func() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.table_func)
  return _internal_mutable_table_func();
}

// .pg_query.Expr expr = 4 [json_name = "Expr"];
inline bool Node::_internal_has_expr() const {
  return node_case() == kExpr;
}
inline bool Node::has_expr() const {
  return _internal_has_expr();
}
inline void Node::set_has_expr() {
  _oneof_case_[0] = kExpr;
}
inline void Node::clear_expr() {
  if (_internal_has_expr()) {
    if (GetArena() == nullptr) {
      delete node_.expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Expr* Node::release_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.expr)
  if (_internal_has_expr()) {
    clear_has_node();
      ::pg_query::Expr* temp = node_.expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Expr& Node::_internal_expr() const {
  return _internal_has_expr()
      ? *node_.expr_
      : reinterpret_cast< ::pg_query::Expr&>(::pg_query::_Expr_default_instance_);
}
inline const ::pg_query::Expr& Node::expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.expr)
  return _internal_expr();
}
inline ::pg_query::Expr* Node::unsafe_arena_release_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.expr)
  if (_internal_has_expr()) {
    clear_has_node();
    ::pg_query::Expr* temp = node_.expr_;
    node_.expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_expr(::pg_query::Expr* expr) {
  clear_node();
  if (expr) {
    set_has_expr();
    node_.expr_ = expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.expr)
}
inline ::pg_query::Expr* Node::_internal_mutable_expr() {
  if (!_internal_has_expr()) {
    clear_node();
    set_has_expr();
    node_.expr_ = CreateMaybeMessage< ::pg_query::Expr >(GetArena());
  }
  return node_.expr_;
}
inline ::pg_query::Expr* Node::mutable_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.expr)
  return _internal_mutable_expr();
}

// .pg_query.Var var = 5 [json_name = "Var"];
inline bool Node::_internal_has_var() const {
  return node_case() == kVar;
}
inline bool Node::has_var() const {
  return _internal_has_var();
}
inline void Node::set_has_var() {
  _oneof_case_[0] = kVar;
}
inline void Node::clear_var() {
  if (_internal_has_var()) {
    if (GetArena() == nullptr) {
      delete node_.var_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Var* Node::release_var() {
  // @@protoc_insertion_point(field_release:pg_query.Node.var)
  if (_internal_has_var()) {
    clear_has_node();
      ::pg_query::Var* temp = node_.var_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.var_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Var& Node::_internal_var() const {
  return _internal_has_var()
      ? *node_.var_
      : reinterpret_cast< ::pg_query::Var&>(::pg_query::_Var_default_instance_);
}
inline const ::pg_query::Var& Node::var() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.var)
  return _internal_var();
}
inline ::pg_query::Var* Node::unsafe_arena_release_var() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.var)
  if (_internal_has_var()) {
    clear_has_node();
    ::pg_query::Var* temp = node_.var_;
    node_.var_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_var(::pg_query::Var* var) {
  clear_node();
  if (var) {
    set_has_var();
    node_.var_ = var;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.var)
}
inline ::pg_query::Var* Node::_internal_mutable_var() {
  if (!_internal_has_var()) {
    clear_node();
    set_has_var();
    node_.var_ = CreateMaybeMessage< ::pg_query::Var >(GetArena());
  }
  return node_.var_;
}
inline ::pg_query::Var* Node::mutable_var() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.var)
  return _internal_mutable_var();
}

// .pg_query.Param param = 6 [json_name = "Param"];
inline bool Node::_internal_has_param() const {
  return node_case() == kParam;
}
inline bool Node::has_param() const {
  return _internal_has_param();
}
inline void Node::set_has_param() {
  _oneof_case_[0] = kParam;
}
inline void Node::clear_param() {
  if (_internal_has_param()) {
    if (GetArena() == nullptr) {
      delete node_.param_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Param* Node::release_param() {
  // @@protoc_insertion_point(field_release:pg_query.Node.param)
  if (_internal_has_param()) {
    clear_has_node();
      ::pg_query::Param* temp = node_.param_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.param_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Param& Node::_internal_param() const {
  return _internal_has_param()
      ? *node_.param_
      : reinterpret_cast< ::pg_query::Param&>(::pg_query::_Param_default_instance_);
}
inline const ::pg_query::Param& Node::param() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.param)
  return _internal_param();
}
inline ::pg_query::Param* Node::unsafe_arena_release_param() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.param)
  if (_internal_has_param()) {
    clear_has_node();
    ::pg_query::Param* temp = node_.param_;
    node_.param_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_param(::pg_query::Param* param) {
  clear_node();
  if (param) {
    set_has_param();
    node_.param_ = param;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.param)
}
inline ::pg_query::Param* Node::_internal_mutable_param() {
  if (!_internal_has_param()) {
    clear_node();
    set_has_param();
    node_.param_ = CreateMaybeMessage< ::pg_query::Param >(GetArena());
  }
  return node_.param_;
}
inline ::pg_query::Param* Node::mutable_param() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.param)
  return _internal_mutable_param();
}

// .pg_query.Aggref aggref = 7 [json_name = "Aggref"];
inline bool Node::_internal_has_aggref() const {
  return node_case() == kAggref;
}
inline bool Node::has_aggref() const {
  return _internal_has_aggref();
}
inline void Node::set_has_aggref() {
  _oneof_case_[0] = kAggref;
}
inline void Node::clear_aggref() {
  if (_internal_has_aggref()) {
    if (GetArena() == nullptr) {
      delete node_.aggref_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Aggref* Node::release_aggref() {
  // @@protoc_insertion_point(field_release:pg_query.Node.aggref)
  if (_internal_has_aggref()) {
    clear_has_node();
      ::pg_query::Aggref* temp = node_.aggref_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.aggref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Aggref& Node::_internal_aggref() const {
  return _internal_has_aggref()
      ? *node_.aggref_
      : reinterpret_cast< ::pg_query::Aggref&>(::pg_query::_Aggref_default_instance_);
}
inline const ::pg_query::Aggref& Node::aggref() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.aggref)
  return _internal_aggref();
}
inline ::pg_query::Aggref* Node::unsafe_arena_release_aggref() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.aggref)
  if (_internal_has_aggref()) {
    clear_has_node();
    ::pg_query::Aggref* temp = node_.aggref_;
    node_.aggref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_aggref(::pg_query::Aggref* aggref) {
  clear_node();
  if (aggref) {
    set_has_aggref();
    node_.aggref_ = aggref;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.aggref)
}
inline ::pg_query::Aggref* Node::_internal_mutable_aggref() {
  if (!_internal_has_aggref()) {
    clear_node();
    set_has_aggref();
    node_.aggref_ = CreateMaybeMessage< ::pg_query::Aggref >(GetArena());
  }
  return node_.aggref_;
}
inline ::pg_query::Aggref* Node::mutable_aggref() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.aggref)
  return _internal_mutable_aggref();
}

// .pg_query.GroupingFunc grouping_func = 8 [json_name = "GroupingFunc"];
inline bool Node::_internal_has_grouping_func() const {
  return node_case() == kGroupingFunc;
}
inline bool Node::has_grouping_func() const {
  return _internal_has_grouping_func();
}
inline void Node::set_has_grouping_func() {
  _oneof_case_[0] = kGroupingFunc;
}
inline void Node::clear_grouping_func() {
  if (_internal_has_grouping_func()) {
    if (GetArena() == nullptr) {
      delete node_.grouping_func_;
    }
    clear_has_node();
  }
}
inline ::pg_query::GroupingFunc* Node::release_grouping_func() {
  // @@protoc_insertion_point(field_release:pg_query.Node.grouping_func)
  if (_internal_has_grouping_func()) {
    clear_has_node();
      ::pg_query::GroupingFunc* temp = node_.grouping_func_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.grouping_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::GroupingFunc& Node::_internal_grouping_func() const {
  return _internal_has_grouping_func()
      ? *node_.grouping_func_
      : reinterpret_cast< ::pg_query::GroupingFunc&>(::pg_query::_GroupingFunc_default_instance_);
}
inline const ::pg_query::GroupingFunc& Node::grouping_func() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.grouping_func)
  return _internal_grouping_func();
}
inline ::pg_query::GroupingFunc* Node::unsafe_arena_release_grouping_func() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.grouping_func)
  if (_internal_has_grouping_func()) {
    clear_has_node();
    ::pg_query::GroupingFunc* temp = node_.grouping_func_;
    node_.grouping_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_grouping_func(::pg_query::GroupingFunc* grouping_func) {
  clear_node();
  if (grouping_func) {
    set_has_grouping_func();
    node_.grouping_func_ = grouping_func;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.grouping_func)
}
inline ::pg_query::GroupingFunc* Node::_internal_mutable_grouping_func() {
  if (!_internal_has_grouping_func()) {
    clear_node();
    set_has_grouping_func();
    node_.grouping_func_ = CreateMaybeMessage< ::pg_query::GroupingFunc >(GetArena());
  }
  return node_.grouping_func_;
}
inline ::pg_query::GroupingFunc* Node::mutable_grouping_func() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.grouping_func)
  return _internal_mutable_grouping_func();
}

// .pg_query.WindowFunc window_func = 9 [json_name = "WindowFunc"];
inline bool Node::_internal_has_window_func() const {
  return node_case() == kWindowFunc;
}
inline bool Node::has_window_func() const {
  return _internal_has_window_func();
}
inline void Node::set_has_window_func() {
  _oneof_case_[0] = kWindowFunc;
}
inline void Node::clear_window_func() {
  if (_internal_has_window_func()) {
    if (GetArena() == nullptr) {
      delete node_.window_func_;
    }
    clear_has_node();
  }
}
inline ::pg_query::WindowFunc* Node::release_window_func() {
  // @@protoc_insertion_point(field_release:pg_query.Node.window_func)
  if (_internal_has_window_func()) {
    clear_has_node();
      ::pg_query::WindowFunc* temp = node_.window_func_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.window_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::WindowFunc& Node::_internal_window_func() const {
  return _internal_has_window_func()
      ? *node_.window_func_
      : reinterpret_cast< ::pg_query::WindowFunc&>(::pg_query::_WindowFunc_default_instance_);
}
inline const ::pg_query::WindowFunc& Node::window_func() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.window_func)
  return _internal_window_func();
}
inline ::pg_query::WindowFunc* Node::unsafe_arena_release_window_func() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.window_func)
  if (_internal_has_window_func()) {
    clear_has_node();
    ::pg_query::WindowFunc* temp = node_.window_func_;
    node_.window_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_window_func(::pg_query::WindowFunc* window_func) {
  clear_node();
  if (window_func) {
    set_has_window_func();
    node_.window_func_ = window_func;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.window_func)
}
inline ::pg_query::WindowFunc* Node::_internal_mutable_window_func() {
  if (!_internal_has_window_func()) {
    clear_node();
    set_has_window_func();
    node_.window_func_ = CreateMaybeMessage< ::pg_query::WindowFunc >(GetArena());
  }
  return node_.window_func_;
}
inline ::pg_query::WindowFunc* Node::mutable_window_func() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.window_func)
  return _internal_mutable_window_func();
}

// .pg_query.SubscriptingRef subscripting_ref = 10 [json_name = "SubscriptingRef"];
inline bool Node::_internal_has_subscripting_ref() const {
  return node_case() == kSubscriptingRef;
}
inline bool Node::has_subscripting_ref() const {
  return _internal_has_subscripting_ref();
}
inline void Node::set_has_subscripting_ref() {
  _oneof_case_[0] = kSubscriptingRef;
}
inline void Node::clear_subscripting_ref() {
  if (_internal_has_subscripting_ref()) {
    if (GetArena() == nullptr) {
      delete node_.subscripting_ref_;
    }
    clear_has_node();
  }
}
inline ::pg_query::SubscriptingRef* Node::release_subscripting_ref() {
  // @@protoc_insertion_point(field_release:pg_query.Node.subscripting_ref)
  if (_internal_has_subscripting_ref()) {
    clear_has_node();
      ::pg_query::SubscriptingRef* temp = node_.subscripting_ref_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.subscripting_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SubscriptingRef& Node::_internal_subscripting_ref() const {
  return _internal_has_subscripting_ref()
      ? *node_.subscripting_ref_
      : reinterpret_cast< ::pg_query::SubscriptingRef&>(::pg_query::_SubscriptingRef_default_instance_);
}
inline const ::pg_query::SubscriptingRef& Node::subscripting_ref() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.subscripting_ref)
  return _internal_subscripting_ref();
}
inline ::pg_query::SubscriptingRef* Node::unsafe_arena_release_subscripting_ref() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.subscripting_ref)
  if (_internal_has_subscripting_ref()) {
    clear_has_node();
    ::pg_query::SubscriptingRef* temp = node_.subscripting_ref_;
    node_.subscripting_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_subscripting_ref(::pg_query::SubscriptingRef* subscripting_ref) {
  clear_node();
  if (subscripting_ref) {
    set_has_subscripting_ref();
    node_.subscripting_ref_ = subscripting_ref;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.subscripting_ref)
}
inline ::pg_query::SubscriptingRef* Node::_internal_mutable_subscripting_ref() {
  if (!_internal_has_subscripting_ref()) {
    clear_node();
    set_has_subscripting_ref();
    node_.subscripting_ref_ = CreateMaybeMessage< ::pg_query::SubscriptingRef >(GetArena());
  }
  return node_.subscripting_ref_;
}
inline ::pg_query::SubscriptingRef* Node::mutable_subscripting_ref() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.subscripting_ref)
  return _internal_mutable_subscripting_ref();
}

// .pg_query.FuncExpr func_expr = 11 [json_name = "FuncExpr"];
inline bool Node::_internal_has_func_expr() const {
  return node_case() == kFuncExpr;
}
inline bool Node::has_func_expr() const {
  return _internal_has_func_expr();
}
inline void Node::set_has_func_expr() {
  _oneof_case_[0] = kFuncExpr;
}
inline void Node::clear_func_expr() {
  if (_internal_has_func_expr()) {
    if (GetArena() == nullptr) {
      delete node_.func_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::FuncExpr* Node::release_func_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.func_expr)
  if (_internal_has_func_expr()) {
    clear_has_node();
      ::pg_query::FuncExpr* temp = node_.func_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.func_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FuncExpr& Node::_internal_func_expr() const {
  return _internal_has_func_expr()
      ? *node_.func_expr_
      : reinterpret_cast< ::pg_query::FuncExpr&>(::pg_query::_FuncExpr_default_instance_);
}
inline const ::pg_query::FuncExpr& Node::func_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.func_expr)
  return _internal_func_expr();
}
inline ::pg_query::FuncExpr* Node::unsafe_arena_release_func_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.func_expr)
  if (_internal_has_func_expr()) {
    clear_has_node();
    ::pg_query::FuncExpr* temp = node_.func_expr_;
    node_.func_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_func_expr(::pg_query::FuncExpr* func_expr) {
  clear_node();
  if (func_expr) {
    set_has_func_expr();
    node_.func_expr_ = func_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.func_expr)
}
inline ::pg_query::FuncExpr* Node::_internal_mutable_func_expr() {
  if (!_internal_has_func_expr()) {
    clear_node();
    set_has_func_expr();
    node_.func_expr_ = CreateMaybeMessage< ::pg_query::FuncExpr >(GetArena());
  }
  return node_.func_expr_;
}
inline ::pg_query::FuncExpr* Node::mutable_func_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.func_expr)
  return _internal_mutable_func_expr();
}

// .pg_query.NamedArgExpr named_arg_expr = 12 [json_name = "NamedArgExpr"];
inline bool Node::_internal_has_named_arg_expr() const {
  return node_case() == kNamedArgExpr;
}
inline bool Node::has_named_arg_expr() const {
  return _internal_has_named_arg_expr();
}
inline void Node::set_has_named_arg_expr() {
  _oneof_case_[0] = kNamedArgExpr;
}
inline void Node::clear_named_arg_expr() {
  if (_internal_has_named_arg_expr()) {
    if (GetArena() == nullptr) {
      delete node_.named_arg_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::NamedArgExpr* Node::release_named_arg_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.named_arg_expr)
  if (_internal_has_named_arg_expr()) {
    clear_has_node();
      ::pg_query::NamedArgExpr* temp = node_.named_arg_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.named_arg_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::NamedArgExpr& Node::_internal_named_arg_expr() const {
  return _internal_has_named_arg_expr()
      ? *node_.named_arg_expr_
      : reinterpret_cast< ::pg_query::NamedArgExpr&>(::pg_query::_NamedArgExpr_default_instance_);
}
inline const ::pg_query::NamedArgExpr& Node::named_arg_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.named_arg_expr)
  return _internal_named_arg_expr();
}
inline ::pg_query::NamedArgExpr* Node::unsafe_arena_release_named_arg_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.named_arg_expr)
  if (_internal_has_named_arg_expr()) {
    clear_has_node();
    ::pg_query::NamedArgExpr* temp = node_.named_arg_expr_;
    node_.named_arg_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_named_arg_expr(::pg_query::NamedArgExpr* named_arg_expr) {
  clear_node();
  if (named_arg_expr) {
    set_has_named_arg_expr();
    node_.named_arg_expr_ = named_arg_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.named_arg_expr)
}
inline ::pg_query::NamedArgExpr* Node::_internal_mutable_named_arg_expr() {
  if (!_internal_has_named_arg_expr()) {
    clear_node();
    set_has_named_arg_expr();
    node_.named_arg_expr_ = CreateMaybeMessage< ::pg_query::NamedArgExpr >(GetArena());
  }
  return node_.named_arg_expr_;
}
inline ::pg_query::NamedArgExpr* Node::mutable_named_arg_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.named_arg_expr)
  return _internal_mutable_named_arg_expr();
}

// .pg_query.OpExpr op_expr = 13 [json_name = "OpExpr"];
inline bool Node::_internal_has_op_expr() const {
  return node_case() == kOpExpr;
}
inline bool Node::has_op_expr() const {
  return _internal_has_op_expr();
}
inline void Node::set_has_op_expr() {
  _oneof_case_[0] = kOpExpr;
}
inline void Node::clear_op_expr() {
  if (_internal_has_op_expr()) {
    if (GetArena() == nullptr) {
      delete node_.op_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::OpExpr* Node::release_op_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.op_expr)
  if (_internal_has_op_expr()) {
    clear_has_node();
      ::pg_query::OpExpr* temp = node_.op_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.op_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::OpExpr& Node::_internal_op_expr() const {
  return _internal_has_op_expr()
      ? *node_.op_expr_
      : reinterpret_cast< ::pg_query::OpExpr&>(::pg_query::_OpExpr_default_instance_);
}
inline const ::pg_query::OpExpr& Node::op_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.op_expr)
  return _internal_op_expr();
}
inline ::pg_query::OpExpr* Node::unsafe_arena_release_op_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.op_expr)
  if (_internal_has_op_expr()) {
    clear_has_node();
    ::pg_query::OpExpr* temp = node_.op_expr_;
    node_.op_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_op_expr(::pg_query::OpExpr* op_expr) {
  clear_node();
  if (op_expr) {
    set_has_op_expr();
    node_.op_expr_ = op_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.op_expr)
}
inline ::pg_query::OpExpr* Node::_internal_mutable_op_expr() {
  if (!_internal_has_op_expr()) {
    clear_node();
    set_has_op_expr();
    node_.op_expr_ = CreateMaybeMessage< ::pg_query::OpExpr >(GetArena());
  }
  return node_.op_expr_;
}
inline ::pg_query::OpExpr* Node::mutable_op_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.op_expr)
  return _internal_mutable_op_expr();
}

// .pg_query.DistinctExpr distinct_expr = 14 [json_name = "DistinctExpr"];
inline bool Node::_internal_has_distinct_expr() const {
  return node_case() == kDistinctExpr;
}
inline bool Node::has_distinct_expr() const {
  return _internal_has_distinct_expr();
}
inline void Node::set_has_distinct_expr() {
  _oneof_case_[0] = kDistinctExpr;
}
inline void Node::clear_distinct_expr() {
  if (_internal_has_distinct_expr()) {
    if (GetArena() == nullptr) {
      delete node_.distinct_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DistinctExpr* Node::release_distinct_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.distinct_expr)
  if (_internal_has_distinct_expr()) {
    clear_has_node();
      ::pg_query::DistinctExpr* temp = node_.distinct_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.distinct_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DistinctExpr& Node::_internal_distinct_expr() const {
  return _internal_has_distinct_expr()
      ? *node_.distinct_expr_
      : reinterpret_cast< ::pg_query::DistinctExpr&>(::pg_query::_DistinctExpr_default_instance_);
}
inline const ::pg_query::DistinctExpr& Node::distinct_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.distinct_expr)
  return _internal_distinct_expr();
}
inline ::pg_query::DistinctExpr* Node::unsafe_arena_release_distinct_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.distinct_expr)
  if (_internal_has_distinct_expr()) {
    clear_has_node();
    ::pg_query::DistinctExpr* temp = node_.distinct_expr_;
    node_.distinct_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_distinct_expr(::pg_query::DistinctExpr* distinct_expr) {
  clear_node();
  if (distinct_expr) {
    set_has_distinct_expr();
    node_.distinct_expr_ = distinct_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.distinct_expr)
}
inline ::pg_query::DistinctExpr* Node::_internal_mutable_distinct_expr() {
  if (!_internal_has_distinct_expr()) {
    clear_node();
    set_has_distinct_expr();
    node_.distinct_expr_ = CreateMaybeMessage< ::pg_query::DistinctExpr >(GetArena());
  }
  return node_.distinct_expr_;
}
inline ::pg_query::DistinctExpr* Node::mutable_distinct_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.distinct_expr)
  return _internal_mutable_distinct_expr();
}

// .pg_query.NullIfExpr null_if_expr = 15 [json_name = "NullIfExpr"];
inline bool Node::_internal_has_null_if_expr() const {
  return node_case() == kNullIfExpr;
}
inline bool Node::has_null_if_expr() const {
  return _internal_has_null_if_expr();
}
inline void Node::set_has_null_if_expr() {
  _oneof_case_[0] = kNullIfExpr;
}
inline void Node::clear_null_if_expr() {
  if (_internal_has_null_if_expr()) {
    if (GetArena() == nullptr) {
      delete node_.null_if_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::NullIfExpr* Node::release_null_if_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.null_if_expr)
  if (_internal_has_null_if_expr()) {
    clear_has_node();
      ::pg_query::NullIfExpr* temp = node_.null_if_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.null_if_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::NullIfExpr& Node::_internal_null_if_expr() const {
  return _internal_has_null_if_expr()
      ? *node_.null_if_expr_
      : reinterpret_cast< ::pg_query::NullIfExpr&>(::pg_query::_NullIfExpr_default_instance_);
}
inline const ::pg_query::NullIfExpr& Node::null_if_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.null_if_expr)
  return _internal_null_if_expr();
}
inline ::pg_query::NullIfExpr* Node::unsafe_arena_release_null_if_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.null_if_expr)
  if (_internal_has_null_if_expr()) {
    clear_has_node();
    ::pg_query::NullIfExpr* temp = node_.null_if_expr_;
    node_.null_if_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_null_if_expr(::pg_query::NullIfExpr* null_if_expr) {
  clear_node();
  if (null_if_expr) {
    set_has_null_if_expr();
    node_.null_if_expr_ = null_if_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.null_if_expr)
}
inline ::pg_query::NullIfExpr* Node::_internal_mutable_null_if_expr() {
  if (!_internal_has_null_if_expr()) {
    clear_node();
    set_has_null_if_expr();
    node_.null_if_expr_ = CreateMaybeMessage< ::pg_query::NullIfExpr >(GetArena());
  }
  return node_.null_if_expr_;
}
inline ::pg_query::NullIfExpr* Node::mutable_null_if_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.null_if_expr)
  return _internal_mutable_null_if_expr();
}

// .pg_query.ScalarArrayOpExpr scalar_array_op_expr = 16 [json_name = "ScalarArrayOpExpr"];
inline bool Node::_internal_has_scalar_array_op_expr() const {
  return node_case() == kScalarArrayOpExpr;
}
inline bool Node::has_scalar_array_op_expr() const {
  return _internal_has_scalar_array_op_expr();
}
inline void Node::set_has_scalar_array_op_expr() {
  _oneof_case_[0] = kScalarArrayOpExpr;
}
inline void Node::clear_scalar_array_op_expr() {
  if (_internal_has_scalar_array_op_expr()) {
    if (GetArena() == nullptr) {
      delete node_.scalar_array_op_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ScalarArrayOpExpr* Node::release_scalar_array_op_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.scalar_array_op_expr)
  if (_internal_has_scalar_array_op_expr()) {
    clear_has_node();
      ::pg_query::ScalarArrayOpExpr* temp = node_.scalar_array_op_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.scalar_array_op_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ScalarArrayOpExpr& Node::_internal_scalar_array_op_expr() const {
  return _internal_has_scalar_array_op_expr()
      ? *node_.scalar_array_op_expr_
      : reinterpret_cast< ::pg_query::ScalarArrayOpExpr&>(::pg_query::_ScalarArrayOpExpr_default_instance_);
}
inline const ::pg_query::ScalarArrayOpExpr& Node::scalar_array_op_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.scalar_array_op_expr)
  return _internal_scalar_array_op_expr();
}
inline ::pg_query::ScalarArrayOpExpr* Node::unsafe_arena_release_scalar_array_op_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.scalar_array_op_expr)
  if (_internal_has_scalar_array_op_expr()) {
    clear_has_node();
    ::pg_query::ScalarArrayOpExpr* temp = node_.scalar_array_op_expr_;
    node_.scalar_array_op_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_scalar_array_op_expr(::pg_query::ScalarArrayOpExpr* scalar_array_op_expr) {
  clear_node();
  if (scalar_array_op_expr) {
    set_has_scalar_array_op_expr();
    node_.scalar_array_op_expr_ = scalar_array_op_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.scalar_array_op_expr)
}
inline ::pg_query::ScalarArrayOpExpr* Node::_internal_mutable_scalar_array_op_expr() {
  if (!_internal_has_scalar_array_op_expr()) {
    clear_node();
    set_has_scalar_array_op_expr();
    node_.scalar_array_op_expr_ = CreateMaybeMessage< ::pg_query::ScalarArrayOpExpr >(GetArena());
  }
  return node_.scalar_array_op_expr_;
}
inline ::pg_query::ScalarArrayOpExpr* Node::mutable_scalar_array_op_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.scalar_array_op_expr)
  return _internal_mutable_scalar_array_op_expr();
}

// .pg_query.BoolExpr bool_expr = 17 [json_name = "BoolExpr"];
inline bool Node::_internal_has_bool_expr() const {
  return node_case() == kBoolExpr;
}
inline bool Node::has_bool_expr() const {
  return _internal_has_bool_expr();
}
inline void Node::set_has_bool_expr() {
  _oneof_case_[0] = kBoolExpr;
}
inline void Node::clear_bool_expr() {
  if (_internal_has_bool_expr()) {
    if (GetArena() == nullptr) {
      delete node_.bool_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::BoolExpr* Node::release_bool_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.bool_expr)
  if (_internal_has_bool_expr()) {
    clear_has_node();
      ::pg_query::BoolExpr* temp = node_.bool_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.bool_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::BoolExpr& Node::_internal_bool_expr() const {
  return _internal_has_bool_expr()
      ? *node_.bool_expr_
      : reinterpret_cast< ::pg_query::BoolExpr&>(::pg_query::_BoolExpr_default_instance_);
}
inline const ::pg_query::BoolExpr& Node::bool_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.bool_expr)
  return _internal_bool_expr();
}
inline ::pg_query::BoolExpr* Node::unsafe_arena_release_bool_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.bool_expr)
  if (_internal_has_bool_expr()) {
    clear_has_node();
    ::pg_query::BoolExpr* temp = node_.bool_expr_;
    node_.bool_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_bool_expr(::pg_query::BoolExpr* bool_expr) {
  clear_node();
  if (bool_expr) {
    set_has_bool_expr();
    node_.bool_expr_ = bool_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.bool_expr)
}
inline ::pg_query::BoolExpr* Node::_internal_mutable_bool_expr() {
  if (!_internal_has_bool_expr()) {
    clear_node();
    set_has_bool_expr();
    node_.bool_expr_ = CreateMaybeMessage< ::pg_query::BoolExpr >(GetArena());
  }
  return node_.bool_expr_;
}
inline ::pg_query::BoolExpr* Node::mutable_bool_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.bool_expr)
  return _internal_mutable_bool_expr();
}

// .pg_query.SubLink sub_link = 18 [json_name = "SubLink"];
inline bool Node::_internal_has_sub_link() const {
  return node_case() == kSubLink;
}
inline bool Node::has_sub_link() const {
  return _internal_has_sub_link();
}
inline void Node::set_has_sub_link() {
  _oneof_case_[0] = kSubLink;
}
inline void Node::clear_sub_link() {
  if (_internal_has_sub_link()) {
    if (GetArena() == nullptr) {
      delete node_.sub_link_;
    }
    clear_has_node();
  }
}
inline ::pg_query::SubLink* Node::release_sub_link() {
  // @@protoc_insertion_point(field_release:pg_query.Node.sub_link)
  if (_internal_has_sub_link()) {
    clear_has_node();
      ::pg_query::SubLink* temp = node_.sub_link_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.sub_link_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SubLink& Node::_internal_sub_link() const {
  return _internal_has_sub_link()
      ? *node_.sub_link_
      : reinterpret_cast< ::pg_query::SubLink&>(::pg_query::_SubLink_default_instance_);
}
inline const ::pg_query::SubLink& Node::sub_link() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.sub_link)
  return _internal_sub_link();
}
inline ::pg_query::SubLink* Node::unsafe_arena_release_sub_link() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.sub_link)
  if (_internal_has_sub_link()) {
    clear_has_node();
    ::pg_query::SubLink* temp = node_.sub_link_;
    node_.sub_link_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_sub_link(::pg_query::SubLink* sub_link) {
  clear_node();
  if (sub_link) {
    set_has_sub_link();
    node_.sub_link_ = sub_link;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sub_link)
}
inline ::pg_query::SubLink* Node::_internal_mutable_sub_link() {
  if (!_internal_has_sub_link()) {
    clear_node();
    set_has_sub_link();
    node_.sub_link_ = CreateMaybeMessage< ::pg_query::SubLink >(GetArena());
  }
  return node_.sub_link_;
}
inline ::pg_query::SubLink* Node::mutable_sub_link() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.sub_link)
  return _internal_mutable_sub_link();
}

// .pg_query.SubPlan sub_plan = 19 [json_name = "SubPlan"];
inline bool Node::_internal_has_sub_plan() const {
  return node_case() == kSubPlan;
}
inline bool Node::has_sub_plan() const {
  return _internal_has_sub_plan();
}
inline void Node::set_has_sub_plan() {
  _oneof_case_[0] = kSubPlan;
}
inline void Node::clear_sub_plan() {
  if (_internal_has_sub_plan()) {
    if (GetArena() == nullptr) {
      delete node_.sub_plan_;
    }
    clear_has_node();
  }
}
inline ::pg_query::SubPlan* Node::release_sub_plan() {
  // @@protoc_insertion_point(field_release:pg_query.Node.sub_plan)
  if (_internal_has_sub_plan()) {
    clear_has_node();
      ::pg_query::SubPlan* temp = node_.sub_plan_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.sub_plan_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SubPlan& Node::_internal_sub_plan() const {
  return _internal_has_sub_plan()
      ? *node_.sub_plan_
      : reinterpret_cast< ::pg_query::SubPlan&>(::pg_query::_SubPlan_default_instance_);
}
inline const ::pg_query::SubPlan& Node::sub_plan() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.sub_plan)
  return _internal_sub_plan();
}
inline ::pg_query::SubPlan* Node::unsafe_arena_release_sub_plan() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.sub_plan)
  if (_internal_has_sub_plan()) {
    clear_has_node();
    ::pg_query::SubPlan* temp = node_.sub_plan_;
    node_.sub_plan_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_sub_plan(::pg_query::SubPlan* sub_plan) {
  clear_node();
  if (sub_plan) {
    set_has_sub_plan();
    node_.sub_plan_ = sub_plan;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sub_plan)
}
inline ::pg_query::SubPlan* Node::_internal_mutable_sub_plan() {
  if (!_internal_has_sub_plan()) {
    clear_node();
    set_has_sub_plan();
    node_.sub_plan_ = CreateMaybeMessage< ::pg_query::SubPlan >(GetArena());
  }
  return node_.sub_plan_;
}
inline ::pg_query::SubPlan* Node::mutable_sub_plan() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.sub_plan)
  return _internal_mutable_sub_plan();
}

// .pg_query.AlternativeSubPlan alternative_sub_plan = 20 [json_name = "AlternativeSubPlan"];
inline bool Node::_internal_has_alternative_sub_plan() const {
  return node_case() == kAlternativeSubPlan;
}
inline bool Node::has_alternative_sub_plan() const {
  return _internal_has_alternative_sub_plan();
}
inline void Node::set_has_alternative_sub_plan() {
  _oneof_case_[0] = kAlternativeSubPlan;
}
inline void Node::clear_alternative_sub_plan() {
  if (_internal_has_alternative_sub_plan()) {
    if (GetArena() == nullptr) {
      delete node_.alternative_sub_plan_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlternativeSubPlan* Node::release_alternative_sub_plan() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alternative_sub_plan)
  if (_internal_has_alternative_sub_plan()) {
    clear_has_node();
      ::pg_query::AlternativeSubPlan* temp = node_.alternative_sub_plan_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alternative_sub_plan_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlternativeSubPlan& Node::_internal_alternative_sub_plan() const {
  return _internal_has_alternative_sub_plan()
      ? *node_.alternative_sub_plan_
      : reinterpret_cast< ::pg_query::AlternativeSubPlan&>(::pg_query::_AlternativeSubPlan_default_instance_);
}
inline const ::pg_query::AlternativeSubPlan& Node::alternative_sub_plan() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alternative_sub_plan)
  return _internal_alternative_sub_plan();
}
inline ::pg_query::AlternativeSubPlan* Node::unsafe_arena_release_alternative_sub_plan() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alternative_sub_plan)
  if (_internal_has_alternative_sub_plan()) {
    clear_has_node();
    ::pg_query::AlternativeSubPlan* temp = node_.alternative_sub_plan_;
    node_.alternative_sub_plan_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alternative_sub_plan(::pg_query::AlternativeSubPlan* alternative_sub_plan) {
  clear_node();
  if (alternative_sub_plan) {
    set_has_alternative_sub_plan();
    node_.alternative_sub_plan_ = alternative_sub_plan;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alternative_sub_plan)
}
inline ::pg_query::AlternativeSubPlan* Node::_internal_mutable_alternative_sub_plan() {
  if (!_internal_has_alternative_sub_plan()) {
    clear_node();
    set_has_alternative_sub_plan();
    node_.alternative_sub_plan_ = CreateMaybeMessage< ::pg_query::AlternativeSubPlan >(GetArena());
  }
  return node_.alternative_sub_plan_;
}
inline ::pg_query::AlternativeSubPlan* Node::mutable_alternative_sub_plan() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alternative_sub_plan)
  return _internal_mutable_alternative_sub_plan();
}

// .pg_query.FieldSelect field_select = 21 [json_name = "FieldSelect"];
inline bool Node::_internal_has_field_select() const {
  return node_case() == kFieldSelect;
}
inline bool Node::has_field_select() const {
  return _internal_has_field_select();
}
inline void Node::set_has_field_select() {
  _oneof_case_[0] = kFieldSelect;
}
inline void Node::clear_field_select() {
  if (_internal_has_field_select()) {
    if (GetArena() == nullptr) {
      delete node_.field_select_;
    }
    clear_has_node();
  }
}
inline ::pg_query::FieldSelect* Node::release_field_select() {
  // @@protoc_insertion_point(field_release:pg_query.Node.field_select)
  if (_internal_has_field_select()) {
    clear_has_node();
      ::pg_query::FieldSelect* temp = node_.field_select_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.field_select_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FieldSelect& Node::_internal_field_select() const {
  return _internal_has_field_select()
      ? *node_.field_select_
      : reinterpret_cast< ::pg_query::FieldSelect&>(::pg_query::_FieldSelect_default_instance_);
}
inline const ::pg_query::FieldSelect& Node::field_select() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.field_select)
  return _internal_field_select();
}
inline ::pg_query::FieldSelect* Node::unsafe_arena_release_field_select() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.field_select)
  if (_internal_has_field_select()) {
    clear_has_node();
    ::pg_query::FieldSelect* temp = node_.field_select_;
    node_.field_select_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_field_select(::pg_query::FieldSelect* field_select) {
  clear_node();
  if (field_select) {
    set_has_field_select();
    node_.field_select_ = field_select;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.field_select)
}
inline ::pg_query::FieldSelect* Node::_internal_mutable_field_select() {
  if (!_internal_has_field_select()) {
    clear_node();
    set_has_field_select();
    node_.field_select_ = CreateMaybeMessage< ::pg_query::FieldSelect >(GetArena());
  }
  return node_.field_select_;
}
inline ::pg_query::FieldSelect* Node::mutable_field_select() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.field_select)
  return _internal_mutable_field_select();
}

// .pg_query.FieldStore field_store = 22 [json_name = "FieldStore"];
inline bool Node::_internal_has_field_store() const {
  return node_case() == kFieldStore;
}
inline bool Node::has_field_store() const {
  return _internal_has_field_store();
}
inline void Node::set_has_field_store() {
  _oneof_case_[0] = kFieldStore;
}
inline void Node::clear_field_store() {
  if (_internal_has_field_store()) {
    if (GetArena() == nullptr) {
      delete node_.field_store_;
    }
    clear_has_node();
  }
}
inline ::pg_query::FieldStore* Node::release_field_store() {
  // @@protoc_insertion_point(field_release:pg_query.Node.field_store)
  if (_internal_has_field_store()) {
    clear_has_node();
      ::pg_query::FieldStore* temp = node_.field_store_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.field_store_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FieldStore& Node::_internal_field_store() const {
  return _internal_has_field_store()
      ? *node_.field_store_
      : reinterpret_cast< ::pg_query::FieldStore&>(::pg_query::_FieldStore_default_instance_);
}
inline const ::pg_query::FieldStore& Node::field_store() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.field_store)
  return _internal_field_store();
}
inline ::pg_query::FieldStore* Node::unsafe_arena_release_field_store() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.field_store)
  if (_internal_has_field_store()) {
    clear_has_node();
    ::pg_query::FieldStore* temp = node_.field_store_;
    node_.field_store_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_field_store(::pg_query::FieldStore* field_store) {
  clear_node();
  if (field_store) {
    set_has_field_store();
    node_.field_store_ = field_store;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.field_store)
}
inline ::pg_query::FieldStore* Node::_internal_mutable_field_store() {
  if (!_internal_has_field_store()) {
    clear_node();
    set_has_field_store();
    node_.field_store_ = CreateMaybeMessage< ::pg_query::FieldStore >(GetArena());
  }
  return node_.field_store_;
}
inline ::pg_query::FieldStore* Node::mutable_field_store() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.field_store)
  return _internal_mutable_field_store();
}

// .pg_query.RelabelType relabel_type = 23 [json_name = "RelabelType"];
inline bool Node::_internal_has_relabel_type() const {
  return node_case() == kRelabelType;
}
inline bool Node::has_relabel_type() const {
  return _internal_has_relabel_type();
}
inline void Node::set_has_relabel_type() {
  _oneof_case_[0] = kRelabelType;
}
inline void Node::clear_relabel_type() {
  if (_internal_has_relabel_type()) {
    if (GetArena() == nullptr) {
      delete node_.relabel_type_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RelabelType* Node::release_relabel_type() {
  // @@protoc_insertion_point(field_release:pg_query.Node.relabel_type)
  if (_internal_has_relabel_type()) {
    clear_has_node();
      ::pg_query::RelabelType* temp = node_.relabel_type_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.relabel_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RelabelType& Node::_internal_relabel_type() const {
  return _internal_has_relabel_type()
      ? *node_.relabel_type_
      : reinterpret_cast< ::pg_query::RelabelType&>(::pg_query::_RelabelType_default_instance_);
}
inline const ::pg_query::RelabelType& Node::relabel_type() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.relabel_type)
  return _internal_relabel_type();
}
inline ::pg_query::RelabelType* Node::unsafe_arena_release_relabel_type() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.relabel_type)
  if (_internal_has_relabel_type()) {
    clear_has_node();
    ::pg_query::RelabelType* temp = node_.relabel_type_;
    node_.relabel_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_relabel_type(::pg_query::RelabelType* relabel_type) {
  clear_node();
  if (relabel_type) {
    set_has_relabel_type();
    node_.relabel_type_ = relabel_type;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.relabel_type)
}
inline ::pg_query::RelabelType* Node::_internal_mutable_relabel_type() {
  if (!_internal_has_relabel_type()) {
    clear_node();
    set_has_relabel_type();
    node_.relabel_type_ = CreateMaybeMessage< ::pg_query::RelabelType >(GetArena());
  }
  return node_.relabel_type_;
}
inline ::pg_query::RelabelType* Node::mutable_relabel_type() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.relabel_type)
  return _internal_mutable_relabel_type();
}

// .pg_query.CoerceViaIO coerce_via_io = 24 [json_name = "CoerceViaIO"];
inline bool Node::_internal_has_coerce_via_io() const {
  return node_case() == kCoerceViaIo;
}
inline bool Node::has_coerce_via_io() const {
  return _internal_has_coerce_via_io();
}
inline void Node::set_has_coerce_via_io() {
  _oneof_case_[0] = kCoerceViaIo;
}
inline void Node::clear_coerce_via_io() {
  if (_internal_has_coerce_via_io()) {
    if (GetArena() == nullptr) {
      delete node_.coerce_via_io_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CoerceViaIO* Node::release_coerce_via_io() {
  // @@protoc_insertion_point(field_release:pg_query.Node.coerce_via_io)
  if (_internal_has_coerce_via_io()) {
    clear_has_node();
      ::pg_query::CoerceViaIO* temp = node_.coerce_via_io_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.coerce_via_io_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CoerceViaIO& Node::_internal_coerce_via_io() const {
  return _internal_has_coerce_via_io()
      ? *node_.coerce_via_io_
      : reinterpret_cast< ::pg_query::CoerceViaIO&>(::pg_query::_CoerceViaIO_default_instance_);
}
inline const ::pg_query::CoerceViaIO& Node::coerce_via_io() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.coerce_via_io)
  return _internal_coerce_via_io();
}
inline ::pg_query::CoerceViaIO* Node::unsafe_arena_release_coerce_via_io() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.coerce_via_io)
  if (_internal_has_coerce_via_io()) {
    clear_has_node();
    ::pg_query::CoerceViaIO* temp = node_.coerce_via_io_;
    node_.coerce_via_io_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_coerce_via_io(::pg_query::CoerceViaIO* coerce_via_io) {
  clear_node();
  if (coerce_via_io) {
    set_has_coerce_via_io();
    node_.coerce_via_io_ = coerce_via_io;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.coerce_via_io)
}
inline ::pg_query::CoerceViaIO* Node::_internal_mutable_coerce_via_io() {
  if (!_internal_has_coerce_via_io()) {
    clear_node();
    set_has_coerce_via_io();
    node_.coerce_via_io_ = CreateMaybeMessage< ::pg_query::CoerceViaIO >(GetArena());
  }
  return node_.coerce_via_io_;
}
inline ::pg_query::CoerceViaIO* Node::mutable_coerce_via_io() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.coerce_via_io)
  return _internal_mutable_coerce_via_io();
}

// .pg_query.ArrayCoerceExpr array_coerce_expr = 25 [json_name = "ArrayCoerceExpr"];
inline bool Node::_internal_has_array_coerce_expr() const {
  return node_case() == kArrayCoerceExpr;
}
inline bool Node::has_array_coerce_expr() const {
  return _internal_has_array_coerce_expr();
}
inline void Node::set_has_array_coerce_expr() {
  _oneof_case_[0] = kArrayCoerceExpr;
}
inline void Node::clear_array_coerce_expr() {
  if (_internal_has_array_coerce_expr()) {
    if (GetArena() == nullptr) {
      delete node_.array_coerce_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ArrayCoerceExpr* Node::release_array_coerce_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.array_coerce_expr)
  if (_internal_has_array_coerce_expr()) {
    clear_has_node();
      ::pg_query::ArrayCoerceExpr* temp = node_.array_coerce_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.array_coerce_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ArrayCoerceExpr& Node::_internal_array_coerce_expr() const {
  return _internal_has_array_coerce_expr()
      ? *node_.array_coerce_expr_
      : reinterpret_cast< ::pg_query::ArrayCoerceExpr&>(::pg_query::_ArrayCoerceExpr_default_instance_);
}
inline const ::pg_query::ArrayCoerceExpr& Node::array_coerce_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.array_coerce_expr)
  return _internal_array_coerce_expr();
}
inline ::pg_query::ArrayCoerceExpr* Node::unsafe_arena_release_array_coerce_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.array_coerce_expr)
  if (_internal_has_array_coerce_expr()) {
    clear_has_node();
    ::pg_query::ArrayCoerceExpr* temp = node_.array_coerce_expr_;
    node_.array_coerce_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_array_coerce_expr(::pg_query::ArrayCoerceExpr* array_coerce_expr) {
  clear_node();
  if (array_coerce_expr) {
    set_has_array_coerce_expr();
    node_.array_coerce_expr_ = array_coerce_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.array_coerce_expr)
}
inline ::pg_query::ArrayCoerceExpr* Node::_internal_mutable_array_coerce_expr() {
  if (!_internal_has_array_coerce_expr()) {
    clear_node();
    set_has_array_coerce_expr();
    node_.array_coerce_expr_ = CreateMaybeMessage< ::pg_query::ArrayCoerceExpr >(GetArena());
  }
  return node_.array_coerce_expr_;
}
inline ::pg_query::ArrayCoerceExpr* Node::mutable_array_coerce_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.array_coerce_expr)
  return _internal_mutable_array_coerce_expr();
}

// .pg_query.ConvertRowtypeExpr convert_rowtype_expr = 26 [json_name = "ConvertRowtypeExpr"];
inline bool Node::_internal_has_convert_rowtype_expr() const {
  return node_case() == kConvertRowtypeExpr;
}
inline bool Node::has_convert_rowtype_expr() const {
  return _internal_has_convert_rowtype_expr();
}
inline void Node::set_has_convert_rowtype_expr() {
  _oneof_case_[0] = kConvertRowtypeExpr;
}
inline void Node::clear_convert_rowtype_expr() {
  if (_internal_has_convert_rowtype_expr()) {
    if (GetArena() == nullptr) {
      delete node_.convert_rowtype_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ConvertRowtypeExpr* Node::release_convert_rowtype_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.convert_rowtype_expr)
  if (_internal_has_convert_rowtype_expr()) {
    clear_has_node();
      ::pg_query::ConvertRowtypeExpr* temp = node_.convert_rowtype_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.convert_rowtype_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ConvertRowtypeExpr& Node::_internal_convert_rowtype_expr() const {
  return _internal_has_convert_rowtype_expr()
      ? *node_.convert_rowtype_expr_
      : reinterpret_cast< ::pg_query::ConvertRowtypeExpr&>(::pg_query::_ConvertRowtypeExpr_default_instance_);
}
inline const ::pg_query::ConvertRowtypeExpr& Node::convert_rowtype_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.convert_rowtype_expr)
  return _internal_convert_rowtype_expr();
}
inline ::pg_query::ConvertRowtypeExpr* Node::unsafe_arena_release_convert_rowtype_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.convert_rowtype_expr)
  if (_internal_has_convert_rowtype_expr()) {
    clear_has_node();
    ::pg_query::ConvertRowtypeExpr* temp = node_.convert_rowtype_expr_;
    node_.convert_rowtype_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_convert_rowtype_expr(::pg_query::ConvertRowtypeExpr* convert_rowtype_expr) {
  clear_node();
  if (convert_rowtype_expr) {
    set_has_convert_rowtype_expr();
    node_.convert_rowtype_expr_ = convert_rowtype_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.convert_rowtype_expr)
}
inline ::pg_query::ConvertRowtypeExpr* Node::_internal_mutable_convert_rowtype_expr() {
  if (!_internal_has_convert_rowtype_expr()) {
    clear_node();
    set_has_convert_rowtype_expr();
    node_.convert_rowtype_expr_ = CreateMaybeMessage< ::pg_query::ConvertRowtypeExpr >(GetArena());
  }
  return node_.convert_rowtype_expr_;
}
inline ::pg_query::ConvertRowtypeExpr* Node::mutable_convert_rowtype_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.convert_rowtype_expr)
  return _internal_mutable_convert_rowtype_expr();
}

// .pg_query.CollateExpr collate_expr = 27 [json_name = "CollateExpr"];
inline bool Node::_internal_has_collate_expr() const {
  return node_case() == kCollateExpr;
}
inline bool Node::has_collate_expr() const {
  return _internal_has_collate_expr();
}
inline void Node::set_has_collate_expr() {
  _oneof_case_[0] = kCollateExpr;
}
inline void Node::clear_collate_expr() {
  if (_internal_has_collate_expr()) {
    if (GetArena() == nullptr) {
      delete node_.collate_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CollateExpr* Node::release_collate_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.collate_expr)
  if (_internal_has_collate_expr()) {
    clear_has_node();
      ::pg_query::CollateExpr* temp = node_.collate_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.collate_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CollateExpr& Node::_internal_collate_expr() const {
  return _internal_has_collate_expr()
      ? *node_.collate_expr_
      : reinterpret_cast< ::pg_query::CollateExpr&>(::pg_query::_CollateExpr_default_instance_);
}
inline const ::pg_query::CollateExpr& Node::collate_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.collate_expr)
  return _internal_collate_expr();
}
inline ::pg_query::CollateExpr* Node::unsafe_arena_release_collate_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.collate_expr)
  if (_internal_has_collate_expr()) {
    clear_has_node();
    ::pg_query::CollateExpr* temp = node_.collate_expr_;
    node_.collate_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_collate_expr(::pg_query::CollateExpr* collate_expr) {
  clear_node();
  if (collate_expr) {
    set_has_collate_expr();
    node_.collate_expr_ = collate_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.collate_expr)
}
inline ::pg_query::CollateExpr* Node::_internal_mutable_collate_expr() {
  if (!_internal_has_collate_expr()) {
    clear_node();
    set_has_collate_expr();
    node_.collate_expr_ = CreateMaybeMessage< ::pg_query::CollateExpr >(GetArena());
  }
  return node_.collate_expr_;
}
inline ::pg_query::CollateExpr* Node::mutable_collate_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.collate_expr)
  return _internal_mutable_collate_expr();
}

// .pg_query.CaseExpr case_expr = 28 [json_name = "CaseExpr"];
inline bool Node::_internal_has_case_expr() const {
  return node_case() == kCaseExpr;
}
inline bool Node::has_case_expr() const {
  return _internal_has_case_expr();
}
inline void Node::set_has_case_expr() {
  _oneof_case_[0] = kCaseExpr;
}
inline void Node::clear_case_expr() {
  if (_internal_has_case_expr()) {
    if (GetArena() == nullptr) {
      delete node_.case_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CaseExpr* Node::release_case_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.case_expr)
  if (_internal_has_case_expr()) {
    clear_has_node();
      ::pg_query::CaseExpr* temp = node_.case_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.case_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CaseExpr& Node::_internal_case_expr() const {
  return _internal_has_case_expr()
      ? *node_.case_expr_
      : reinterpret_cast< ::pg_query::CaseExpr&>(::pg_query::_CaseExpr_default_instance_);
}
inline const ::pg_query::CaseExpr& Node::case_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.case_expr)
  return _internal_case_expr();
}
inline ::pg_query::CaseExpr* Node::unsafe_arena_release_case_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.case_expr)
  if (_internal_has_case_expr()) {
    clear_has_node();
    ::pg_query::CaseExpr* temp = node_.case_expr_;
    node_.case_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_case_expr(::pg_query::CaseExpr* case_expr) {
  clear_node();
  if (case_expr) {
    set_has_case_expr();
    node_.case_expr_ = case_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.case_expr)
}
inline ::pg_query::CaseExpr* Node::_internal_mutable_case_expr() {
  if (!_internal_has_case_expr()) {
    clear_node();
    set_has_case_expr();
    node_.case_expr_ = CreateMaybeMessage< ::pg_query::CaseExpr >(GetArena());
  }
  return node_.case_expr_;
}
inline ::pg_query::CaseExpr* Node::mutable_case_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.case_expr)
  return _internal_mutable_case_expr();
}

// .pg_query.CaseWhen case_when = 29 [json_name = "CaseWhen"];
inline bool Node::_internal_has_case_when() const {
  return node_case() == kCaseWhen;
}
inline bool Node::has_case_when() const {
  return _internal_has_case_when();
}
inline void Node::set_has_case_when() {
  _oneof_case_[0] = kCaseWhen;
}
inline void Node::clear_case_when() {
  if (_internal_has_case_when()) {
    if (GetArena() == nullptr) {
      delete node_.case_when_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CaseWhen* Node::release_case_when() {
  // @@protoc_insertion_point(field_release:pg_query.Node.case_when)
  if (_internal_has_case_when()) {
    clear_has_node();
      ::pg_query::CaseWhen* temp = node_.case_when_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.case_when_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CaseWhen& Node::_internal_case_when() const {
  return _internal_has_case_when()
      ? *node_.case_when_
      : reinterpret_cast< ::pg_query::CaseWhen&>(::pg_query::_CaseWhen_default_instance_);
}
inline const ::pg_query::CaseWhen& Node::case_when() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.case_when)
  return _internal_case_when();
}
inline ::pg_query::CaseWhen* Node::unsafe_arena_release_case_when() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.case_when)
  if (_internal_has_case_when()) {
    clear_has_node();
    ::pg_query::CaseWhen* temp = node_.case_when_;
    node_.case_when_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_case_when(::pg_query::CaseWhen* case_when) {
  clear_node();
  if (case_when) {
    set_has_case_when();
    node_.case_when_ = case_when;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.case_when)
}
inline ::pg_query::CaseWhen* Node::_internal_mutable_case_when() {
  if (!_internal_has_case_when()) {
    clear_node();
    set_has_case_when();
    node_.case_when_ = CreateMaybeMessage< ::pg_query::CaseWhen >(GetArena());
  }
  return node_.case_when_;
}
inline ::pg_query::CaseWhen* Node::mutable_case_when() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.case_when)
  return _internal_mutable_case_when();
}

// .pg_query.CaseTestExpr case_test_expr = 30 [json_name = "CaseTestExpr"];
inline bool Node::_internal_has_case_test_expr() const {
  return node_case() == kCaseTestExpr;
}
inline bool Node::has_case_test_expr() const {
  return _internal_has_case_test_expr();
}
inline void Node::set_has_case_test_expr() {
  _oneof_case_[0] = kCaseTestExpr;
}
inline void Node::clear_case_test_expr() {
  if (_internal_has_case_test_expr()) {
    if (GetArena() == nullptr) {
      delete node_.case_test_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CaseTestExpr* Node::release_case_test_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.case_test_expr)
  if (_internal_has_case_test_expr()) {
    clear_has_node();
      ::pg_query::CaseTestExpr* temp = node_.case_test_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.case_test_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CaseTestExpr& Node::_internal_case_test_expr() const {
  return _internal_has_case_test_expr()
      ? *node_.case_test_expr_
      : reinterpret_cast< ::pg_query::CaseTestExpr&>(::pg_query::_CaseTestExpr_default_instance_);
}
inline const ::pg_query::CaseTestExpr& Node::case_test_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.case_test_expr)
  return _internal_case_test_expr();
}
inline ::pg_query::CaseTestExpr* Node::unsafe_arena_release_case_test_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.case_test_expr)
  if (_internal_has_case_test_expr()) {
    clear_has_node();
    ::pg_query::CaseTestExpr* temp = node_.case_test_expr_;
    node_.case_test_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_case_test_expr(::pg_query::CaseTestExpr* case_test_expr) {
  clear_node();
  if (case_test_expr) {
    set_has_case_test_expr();
    node_.case_test_expr_ = case_test_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.case_test_expr)
}
inline ::pg_query::CaseTestExpr* Node::_internal_mutable_case_test_expr() {
  if (!_internal_has_case_test_expr()) {
    clear_node();
    set_has_case_test_expr();
    node_.case_test_expr_ = CreateMaybeMessage< ::pg_query::CaseTestExpr >(GetArena());
  }
  return node_.case_test_expr_;
}
inline ::pg_query::CaseTestExpr* Node::mutable_case_test_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.case_test_expr)
  return _internal_mutable_case_test_expr();
}

// .pg_query.ArrayExpr array_expr = 31 [json_name = "ArrayExpr"];
inline bool Node::_internal_has_array_expr() const {
  return node_case() == kArrayExpr;
}
inline bool Node::has_array_expr() const {
  return _internal_has_array_expr();
}
inline void Node::set_has_array_expr() {
  _oneof_case_[0] = kArrayExpr;
}
inline void Node::clear_array_expr() {
  if (_internal_has_array_expr()) {
    if (GetArena() == nullptr) {
      delete node_.array_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ArrayExpr* Node::release_array_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.array_expr)
  if (_internal_has_array_expr()) {
    clear_has_node();
      ::pg_query::ArrayExpr* temp = node_.array_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.array_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ArrayExpr& Node::_internal_array_expr() const {
  return _internal_has_array_expr()
      ? *node_.array_expr_
      : reinterpret_cast< ::pg_query::ArrayExpr&>(::pg_query::_ArrayExpr_default_instance_);
}
inline const ::pg_query::ArrayExpr& Node::array_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.array_expr)
  return _internal_array_expr();
}
inline ::pg_query::ArrayExpr* Node::unsafe_arena_release_array_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.array_expr)
  if (_internal_has_array_expr()) {
    clear_has_node();
    ::pg_query::ArrayExpr* temp = node_.array_expr_;
    node_.array_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_array_expr(::pg_query::ArrayExpr* array_expr) {
  clear_node();
  if (array_expr) {
    set_has_array_expr();
    node_.array_expr_ = array_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.array_expr)
}
inline ::pg_query::ArrayExpr* Node::_internal_mutable_array_expr() {
  if (!_internal_has_array_expr()) {
    clear_node();
    set_has_array_expr();
    node_.array_expr_ = CreateMaybeMessage< ::pg_query::ArrayExpr >(GetArena());
  }
  return node_.array_expr_;
}
inline ::pg_query::ArrayExpr* Node::mutable_array_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.array_expr)
  return _internal_mutable_array_expr();
}

// .pg_query.RowExpr row_expr = 32 [json_name = "RowExpr"];
inline bool Node::_internal_has_row_expr() const {
  return node_case() == kRowExpr;
}
inline bool Node::has_row_expr() const {
  return _internal_has_row_expr();
}
inline void Node::set_has_row_expr() {
  _oneof_case_[0] = kRowExpr;
}
inline void Node::clear_row_expr() {
  if (_internal_has_row_expr()) {
    if (GetArena() == nullptr) {
      delete node_.row_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RowExpr* Node::release_row_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.row_expr)
  if (_internal_has_row_expr()) {
    clear_has_node();
      ::pg_query::RowExpr* temp = node_.row_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.row_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RowExpr& Node::_internal_row_expr() const {
  return _internal_has_row_expr()
      ? *node_.row_expr_
      : reinterpret_cast< ::pg_query::RowExpr&>(::pg_query::_RowExpr_default_instance_);
}
inline const ::pg_query::RowExpr& Node::row_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.row_expr)
  return _internal_row_expr();
}
inline ::pg_query::RowExpr* Node::unsafe_arena_release_row_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.row_expr)
  if (_internal_has_row_expr()) {
    clear_has_node();
    ::pg_query::RowExpr* temp = node_.row_expr_;
    node_.row_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_row_expr(::pg_query::RowExpr* row_expr) {
  clear_node();
  if (row_expr) {
    set_has_row_expr();
    node_.row_expr_ = row_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.row_expr)
}
inline ::pg_query::RowExpr* Node::_internal_mutable_row_expr() {
  if (!_internal_has_row_expr()) {
    clear_node();
    set_has_row_expr();
    node_.row_expr_ = CreateMaybeMessage< ::pg_query::RowExpr >(GetArena());
  }
  return node_.row_expr_;
}
inline ::pg_query::RowExpr* Node::mutable_row_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.row_expr)
  return _internal_mutable_row_expr();
}

// .pg_query.RowCompareExpr row_compare_expr = 33 [json_name = "RowCompareExpr"];
inline bool Node::_internal_has_row_compare_expr() const {
  return node_case() == kRowCompareExpr;
}
inline bool Node::has_row_compare_expr() const {
  return _internal_has_row_compare_expr();
}
inline void Node::set_has_row_compare_expr() {
  _oneof_case_[0] = kRowCompareExpr;
}
inline void Node::clear_row_compare_expr() {
  if (_internal_has_row_compare_expr()) {
    if (GetArena() == nullptr) {
      delete node_.row_compare_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RowCompareExpr* Node::release_row_compare_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.row_compare_expr)
  if (_internal_has_row_compare_expr()) {
    clear_has_node();
      ::pg_query::RowCompareExpr* temp = node_.row_compare_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.row_compare_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RowCompareExpr& Node::_internal_row_compare_expr() const {
  return _internal_has_row_compare_expr()
      ? *node_.row_compare_expr_
      : reinterpret_cast< ::pg_query::RowCompareExpr&>(::pg_query::_RowCompareExpr_default_instance_);
}
inline const ::pg_query::RowCompareExpr& Node::row_compare_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.row_compare_expr)
  return _internal_row_compare_expr();
}
inline ::pg_query::RowCompareExpr* Node::unsafe_arena_release_row_compare_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.row_compare_expr)
  if (_internal_has_row_compare_expr()) {
    clear_has_node();
    ::pg_query::RowCompareExpr* temp = node_.row_compare_expr_;
    node_.row_compare_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_row_compare_expr(::pg_query::RowCompareExpr* row_compare_expr) {
  clear_node();
  if (row_compare_expr) {
    set_has_row_compare_expr();
    node_.row_compare_expr_ = row_compare_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.row_compare_expr)
}
inline ::pg_query::RowCompareExpr* Node::_internal_mutable_row_compare_expr() {
  if (!_internal_has_row_compare_expr()) {
    clear_node();
    set_has_row_compare_expr();
    node_.row_compare_expr_ = CreateMaybeMessage< ::pg_query::RowCompareExpr >(GetArena());
  }
  return node_.row_compare_expr_;
}
inline ::pg_query::RowCompareExpr* Node::mutable_row_compare_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.row_compare_expr)
  return _internal_mutable_row_compare_expr();
}

// .pg_query.CoalesceExpr coalesce_expr = 34 [json_name = "CoalesceExpr"];
inline bool Node::_internal_has_coalesce_expr() const {
  return node_case() == kCoalesceExpr;
}
inline bool Node::has_coalesce_expr() const {
  return _internal_has_coalesce_expr();
}
inline void Node::set_has_coalesce_expr() {
  _oneof_case_[0] = kCoalesceExpr;
}
inline void Node::clear_coalesce_expr() {
  if (_internal_has_coalesce_expr()) {
    if (GetArena() == nullptr) {
      delete node_.coalesce_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CoalesceExpr* Node::release_coalesce_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.coalesce_expr)
  if (_internal_has_coalesce_expr()) {
    clear_has_node();
      ::pg_query::CoalesceExpr* temp = node_.coalesce_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.coalesce_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CoalesceExpr& Node::_internal_coalesce_expr() const {
  return _internal_has_coalesce_expr()
      ? *node_.coalesce_expr_
      : reinterpret_cast< ::pg_query::CoalesceExpr&>(::pg_query::_CoalesceExpr_default_instance_);
}
inline const ::pg_query::CoalesceExpr& Node::coalesce_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.coalesce_expr)
  return _internal_coalesce_expr();
}
inline ::pg_query::CoalesceExpr* Node::unsafe_arena_release_coalesce_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.coalesce_expr)
  if (_internal_has_coalesce_expr()) {
    clear_has_node();
    ::pg_query::CoalesceExpr* temp = node_.coalesce_expr_;
    node_.coalesce_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_coalesce_expr(::pg_query::CoalesceExpr* coalesce_expr) {
  clear_node();
  if (coalesce_expr) {
    set_has_coalesce_expr();
    node_.coalesce_expr_ = coalesce_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.coalesce_expr)
}
inline ::pg_query::CoalesceExpr* Node::_internal_mutable_coalesce_expr() {
  if (!_internal_has_coalesce_expr()) {
    clear_node();
    set_has_coalesce_expr();
    node_.coalesce_expr_ = CreateMaybeMessage< ::pg_query::CoalesceExpr >(GetArena());
  }
  return node_.coalesce_expr_;
}
inline ::pg_query::CoalesceExpr* Node::mutable_coalesce_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.coalesce_expr)
  return _internal_mutable_coalesce_expr();
}

// .pg_query.MinMaxExpr min_max_expr = 35 [json_name = "MinMaxExpr"];
inline bool Node::_internal_has_min_max_expr() const {
  return node_case() == kMinMaxExpr;
}
inline bool Node::has_min_max_expr() const {
  return _internal_has_min_max_expr();
}
inline void Node::set_has_min_max_expr() {
  _oneof_case_[0] = kMinMaxExpr;
}
inline void Node::clear_min_max_expr() {
  if (_internal_has_min_max_expr()) {
    if (GetArena() == nullptr) {
      delete node_.min_max_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::MinMaxExpr* Node::release_min_max_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.min_max_expr)
  if (_internal_has_min_max_expr()) {
    clear_has_node();
      ::pg_query::MinMaxExpr* temp = node_.min_max_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.min_max_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::MinMaxExpr& Node::_internal_min_max_expr() const {
  return _internal_has_min_max_expr()
      ? *node_.min_max_expr_
      : reinterpret_cast< ::pg_query::MinMaxExpr&>(::pg_query::_MinMaxExpr_default_instance_);
}
inline const ::pg_query::MinMaxExpr& Node::min_max_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.min_max_expr)
  return _internal_min_max_expr();
}
inline ::pg_query::MinMaxExpr* Node::unsafe_arena_release_min_max_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.min_max_expr)
  if (_internal_has_min_max_expr()) {
    clear_has_node();
    ::pg_query::MinMaxExpr* temp = node_.min_max_expr_;
    node_.min_max_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_min_max_expr(::pg_query::MinMaxExpr* min_max_expr) {
  clear_node();
  if (min_max_expr) {
    set_has_min_max_expr();
    node_.min_max_expr_ = min_max_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.min_max_expr)
}
inline ::pg_query::MinMaxExpr* Node::_internal_mutable_min_max_expr() {
  if (!_internal_has_min_max_expr()) {
    clear_node();
    set_has_min_max_expr();
    node_.min_max_expr_ = CreateMaybeMessage< ::pg_query::MinMaxExpr >(GetArena());
  }
  return node_.min_max_expr_;
}
inline ::pg_query::MinMaxExpr* Node::mutable_min_max_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.min_max_expr)
  return _internal_mutable_min_max_expr();
}

// .pg_query.SQLValueFunction sqlvalue_function = 36 [json_name = "SQLValueFunction"];
inline bool Node::_internal_has_sqlvalue_function() const {
  return node_case() == kSqlvalueFunction;
}
inline bool Node::has_sqlvalue_function() const {
  return _internal_has_sqlvalue_function();
}
inline void Node::set_has_sqlvalue_function() {
  _oneof_case_[0] = kSqlvalueFunction;
}
inline void Node::clear_sqlvalue_function() {
  if (_internal_has_sqlvalue_function()) {
    if (GetArena() == nullptr) {
      delete node_.sqlvalue_function_;
    }
    clear_has_node();
  }
}
inline ::pg_query::SQLValueFunction* Node::release_sqlvalue_function() {
  // @@protoc_insertion_point(field_release:pg_query.Node.sqlvalue_function)
  if (_internal_has_sqlvalue_function()) {
    clear_has_node();
      ::pg_query::SQLValueFunction* temp = node_.sqlvalue_function_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.sqlvalue_function_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SQLValueFunction& Node::_internal_sqlvalue_function() const {
  return _internal_has_sqlvalue_function()
      ? *node_.sqlvalue_function_
      : reinterpret_cast< ::pg_query::SQLValueFunction&>(::pg_query::_SQLValueFunction_default_instance_);
}
inline const ::pg_query::SQLValueFunction& Node::sqlvalue_function() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.sqlvalue_function)
  return _internal_sqlvalue_function();
}
inline ::pg_query::SQLValueFunction* Node::unsafe_arena_release_sqlvalue_function() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.sqlvalue_function)
  if (_internal_has_sqlvalue_function()) {
    clear_has_node();
    ::pg_query::SQLValueFunction* temp = node_.sqlvalue_function_;
    node_.sqlvalue_function_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_sqlvalue_function(::pg_query::SQLValueFunction* sqlvalue_function) {
  clear_node();
  if (sqlvalue_function) {
    set_has_sqlvalue_function();
    node_.sqlvalue_function_ = sqlvalue_function;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sqlvalue_function)
}
inline ::pg_query::SQLValueFunction* Node::_internal_mutable_sqlvalue_function() {
  if (!_internal_has_sqlvalue_function()) {
    clear_node();
    set_has_sqlvalue_function();
    node_.sqlvalue_function_ = CreateMaybeMessage< ::pg_query::SQLValueFunction >(GetArena());
  }
  return node_.sqlvalue_function_;
}
inline ::pg_query::SQLValueFunction* Node::mutable_sqlvalue_function() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.sqlvalue_function)
  return _internal_mutable_sqlvalue_function();
}

// .pg_query.XmlExpr xml_expr = 37 [json_name = "XmlExpr"];
inline bool Node::_internal_has_xml_expr() const {
  return node_case() == kXmlExpr;
}
inline bool Node::has_xml_expr() const {
  return _internal_has_xml_expr();
}
inline void Node::set_has_xml_expr() {
  _oneof_case_[0] = kXmlExpr;
}
inline void Node::clear_xml_expr() {
  if (_internal_has_xml_expr()) {
    if (GetArena() == nullptr) {
      delete node_.xml_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::XmlExpr* Node::release_xml_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.xml_expr)
  if (_internal_has_xml_expr()) {
    clear_has_node();
      ::pg_query::XmlExpr* temp = node_.xml_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.xml_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::XmlExpr& Node::_internal_xml_expr() const {
  return _internal_has_xml_expr()
      ? *node_.xml_expr_
      : reinterpret_cast< ::pg_query::XmlExpr&>(::pg_query::_XmlExpr_default_instance_);
}
inline const ::pg_query::XmlExpr& Node::xml_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.xml_expr)
  return _internal_xml_expr();
}
inline ::pg_query::XmlExpr* Node::unsafe_arena_release_xml_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.xml_expr)
  if (_internal_has_xml_expr()) {
    clear_has_node();
    ::pg_query::XmlExpr* temp = node_.xml_expr_;
    node_.xml_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_xml_expr(::pg_query::XmlExpr* xml_expr) {
  clear_node();
  if (xml_expr) {
    set_has_xml_expr();
    node_.xml_expr_ = xml_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.xml_expr)
}
inline ::pg_query::XmlExpr* Node::_internal_mutable_xml_expr() {
  if (!_internal_has_xml_expr()) {
    clear_node();
    set_has_xml_expr();
    node_.xml_expr_ = CreateMaybeMessage< ::pg_query::XmlExpr >(GetArena());
  }
  return node_.xml_expr_;
}
inline ::pg_query::XmlExpr* Node::mutable_xml_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.xml_expr)
  return _internal_mutable_xml_expr();
}

// .pg_query.NullTest null_test = 38 [json_name = "NullTest"];
inline bool Node::_internal_has_null_test() const {
  return node_case() == kNullTest;
}
inline bool Node::has_null_test() const {
  return _internal_has_null_test();
}
inline void Node::set_has_null_test() {
  _oneof_case_[0] = kNullTest;
}
inline void Node::clear_null_test() {
  if (_internal_has_null_test()) {
    if (GetArena() == nullptr) {
      delete node_.null_test_;
    }
    clear_has_node();
  }
}
inline ::pg_query::NullTest* Node::release_null_test() {
  // @@protoc_insertion_point(field_release:pg_query.Node.null_test)
  if (_internal_has_null_test()) {
    clear_has_node();
      ::pg_query::NullTest* temp = node_.null_test_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.null_test_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::NullTest& Node::_internal_null_test() const {
  return _internal_has_null_test()
      ? *node_.null_test_
      : reinterpret_cast< ::pg_query::NullTest&>(::pg_query::_NullTest_default_instance_);
}
inline const ::pg_query::NullTest& Node::null_test() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.null_test)
  return _internal_null_test();
}
inline ::pg_query::NullTest* Node::unsafe_arena_release_null_test() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.null_test)
  if (_internal_has_null_test()) {
    clear_has_node();
    ::pg_query::NullTest* temp = node_.null_test_;
    node_.null_test_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_null_test(::pg_query::NullTest* null_test) {
  clear_node();
  if (null_test) {
    set_has_null_test();
    node_.null_test_ = null_test;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.null_test)
}
inline ::pg_query::NullTest* Node::_internal_mutable_null_test() {
  if (!_internal_has_null_test()) {
    clear_node();
    set_has_null_test();
    node_.null_test_ = CreateMaybeMessage< ::pg_query::NullTest >(GetArena());
  }
  return node_.null_test_;
}
inline ::pg_query::NullTest* Node::mutable_null_test() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.null_test)
  return _internal_mutable_null_test();
}

// .pg_query.BooleanTest boolean_test = 39 [json_name = "BooleanTest"];
inline bool Node::_internal_has_boolean_test() const {
  return node_case() == kBooleanTest;
}
inline bool Node::has_boolean_test() const {
  return _internal_has_boolean_test();
}
inline void Node::set_has_boolean_test() {
  _oneof_case_[0] = kBooleanTest;
}
inline void Node::clear_boolean_test() {
  if (_internal_has_boolean_test()) {
    if (GetArena() == nullptr) {
      delete node_.boolean_test_;
    }
    clear_has_node();
  }
}
inline ::pg_query::BooleanTest* Node::release_boolean_test() {
  // @@protoc_insertion_point(field_release:pg_query.Node.boolean_test)
  if (_internal_has_boolean_test()) {
    clear_has_node();
      ::pg_query::BooleanTest* temp = node_.boolean_test_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.boolean_test_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::BooleanTest& Node::_internal_boolean_test() const {
  return _internal_has_boolean_test()
      ? *node_.boolean_test_
      : reinterpret_cast< ::pg_query::BooleanTest&>(::pg_query::_BooleanTest_default_instance_);
}
inline const ::pg_query::BooleanTest& Node::boolean_test() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.boolean_test)
  return _internal_boolean_test();
}
inline ::pg_query::BooleanTest* Node::unsafe_arena_release_boolean_test() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.boolean_test)
  if (_internal_has_boolean_test()) {
    clear_has_node();
    ::pg_query::BooleanTest* temp = node_.boolean_test_;
    node_.boolean_test_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_boolean_test(::pg_query::BooleanTest* boolean_test) {
  clear_node();
  if (boolean_test) {
    set_has_boolean_test();
    node_.boolean_test_ = boolean_test;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.boolean_test)
}
inline ::pg_query::BooleanTest* Node::_internal_mutable_boolean_test() {
  if (!_internal_has_boolean_test()) {
    clear_node();
    set_has_boolean_test();
    node_.boolean_test_ = CreateMaybeMessage< ::pg_query::BooleanTest >(GetArena());
  }
  return node_.boolean_test_;
}
inline ::pg_query::BooleanTest* Node::mutable_boolean_test() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.boolean_test)
  return _internal_mutable_boolean_test();
}

// .pg_query.CoerceToDomain coerce_to_domain = 40 [json_name = "CoerceToDomain"];
inline bool Node::_internal_has_coerce_to_domain() const {
  return node_case() == kCoerceToDomain;
}
inline bool Node::has_coerce_to_domain() const {
  return _internal_has_coerce_to_domain();
}
inline void Node::set_has_coerce_to_domain() {
  _oneof_case_[0] = kCoerceToDomain;
}
inline void Node::clear_coerce_to_domain() {
  if (_internal_has_coerce_to_domain()) {
    if (GetArena() == nullptr) {
      delete node_.coerce_to_domain_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CoerceToDomain* Node::release_coerce_to_domain() {
  // @@protoc_insertion_point(field_release:pg_query.Node.coerce_to_domain)
  if (_internal_has_coerce_to_domain()) {
    clear_has_node();
      ::pg_query::CoerceToDomain* temp = node_.coerce_to_domain_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.coerce_to_domain_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CoerceToDomain& Node::_internal_coerce_to_domain() const {
  return _internal_has_coerce_to_domain()
      ? *node_.coerce_to_domain_
      : reinterpret_cast< ::pg_query::CoerceToDomain&>(::pg_query::_CoerceToDomain_default_instance_);
}
inline const ::pg_query::CoerceToDomain& Node::coerce_to_domain() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.coerce_to_domain)
  return _internal_coerce_to_domain();
}
inline ::pg_query::CoerceToDomain* Node::unsafe_arena_release_coerce_to_domain() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.coerce_to_domain)
  if (_internal_has_coerce_to_domain()) {
    clear_has_node();
    ::pg_query::CoerceToDomain* temp = node_.coerce_to_domain_;
    node_.coerce_to_domain_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_coerce_to_domain(::pg_query::CoerceToDomain* coerce_to_domain) {
  clear_node();
  if (coerce_to_domain) {
    set_has_coerce_to_domain();
    node_.coerce_to_domain_ = coerce_to_domain;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.coerce_to_domain)
}
inline ::pg_query::CoerceToDomain* Node::_internal_mutable_coerce_to_domain() {
  if (!_internal_has_coerce_to_domain()) {
    clear_node();
    set_has_coerce_to_domain();
    node_.coerce_to_domain_ = CreateMaybeMessage< ::pg_query::CoerceToDomain >(GetArena());
  }
  return node_.coerce_to_domain_;
}
inline ::pg_query::CoerceToDomain* Node::mutable_coerce_to_domain() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.coerce_to_domain)
  return _internal_mutable_coerce_to_domain();
}

// .pg_query.CoerceToDomainValue coerce_to_domain_value = 41 [json_name = "CoerceToDomainValue"];
inline bool Node::_internal_has_coerce_to_domain_value() const {
  return node_case() == kCoerceToDomainValue;
}
inline bool Node::has_coerce_to_domain_value() const {
  return _internal_has_coerce_to_domain_value();
}
inline void Node::set_has_coerce_to_domain_value() {
  _oneof_case_[0] = kCoerceToDomainValue;
}
inline void Node::clear_coerce_to_domain_value() {
  if (_internal_has_coerce_to_domain_value()) {
    if (GetArena() == nullptr) {
      delete node_.coerce_to_domain_value_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CoerceToDomainValue* Node::release_coerce_to_domain_value() {
  // @@protoc_insertion_point(field_release:pg_query.Node.coerce_to_domain_value)
  if (_internal_has_coerce_to_domain_value()) {
    clear_has_node();
      ::pg_query::CoerceToDomainValue* temp = node_.coerce_to_domain_value_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.coerce_to_domain_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CoerceToDomainValue& Node::_internal_coerce_to_domain_value() const {
  return _internal_has_coerce_to_domain_value()
      ? *node_.coerce_to_domain_value_
      : reinterpret_cast< ::pg_query::CoerceToDomainValue&>(::pg_query::_CoerceToDomainValue_default_instance_);
}
inline const ::pg_query::CoerceToDomainValue& Node::coerce_to_domain_value() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.coerce_to_domain_value)
  return _internal_coerce_to_domain_value();
}
inline ::pg_query::CoerceToDomainValue* Node::unsafe_arena_release_coerce_to_domain_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.coerce_to_domain_value)
  if (_internal_has_coerce_to_domain_value()) {
    clear_has_node();
    ::pg_query::CoerceToDomainValue* temp = node_.coerce_to_domain_value_;
    node_.coerce_to_domain_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_coerce_to_domain_value(::pg_query::CoerceToDomainValue* coerce_to_domain_value) {
  clear_node();
  if (coerce_to_domain_value) {
    set_has_coerce_to_domain_value();
    node_.coerce_to_domain_value_ = coerce_to_domain_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.coerce_to_domain_value)
}
inline ::pg_query::CoerceToDomainValue* Node::_internal_mutable_coerce_to_domain_value() {
  if (!_internal_has_coerce_to_domain_value()) {
    clear_node();
    set_has_coerce_to_domain_value();
    node_.coerce_to_domain_value_ = CreateMaybeMessage< ::pg_query::CoerceToDomainValue >(GetArena());
  }
  return node_.coerce_to_domain_value_;
}
inline ::pg_query::CoerceToDomainValue* Node::mutable_coerce_to_domain_value() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.coerce_to_domain_value)
  return _internal_mutable_coerce_to_domain_value();
}

// .pg_query.SetToDefault set_to_default = 42 [json_name = "SetToDefault"];
inline bool Node::_internal_has_set_to_default() const {
  return node_case() == kSetToDefault;
}
inline bool Node::has_set_to_default() const {
  return _internal_has_set_to_default();
}
inline void Node::set_has_set_to_default() {
  _oneof_case_[0] = kSetToDefault;
}
inline void Node::clear_set_to_default() {
  if (_internal_has_set_to_default()) {
    if (GetArena() == nullptr) {
      delete node_.set_to_default_;
    }
    clear_has_node();
  }
}
inline ::pg_query::SetToDefault* Node::release_set_to_default() {
  // @@protoc_insertion_point(field_release:pg_query.Node.set_to_default)
  if (_internal_has_set_to_default()) {
    clear_has_node();
      ::pg_query::SetToDefault* temp = node_.set_to_default_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.set_to_default_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SetToDefault& Node::_internal_set_to_default() const {
  return _internal_has_set_to_default()
      ? *node_.set_to_default_
      : reinterpret_cast< ::pg_query::SetToDefault&>(::pg_query::_SetToDefault_default_instance_);
}
inline const ::pg_query::SetToDefault& Node::set_to_default() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.set_to_default)
  return _internal_set_to_default();
}
inline ::pg_query::SetToDefault* Node::unsafe_arena_release_set_to_default() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.set_to_default)
  if (_internal_has_set_to_default()) {
    clear_has_node();
    ::pg_query::SetToDefault* temp = node_.set_to_default_;
    node_.set_to_default_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_set_to_default(::pg_query::SetToDefault* set_to_default) {
  clear_node();
  if (set_to_default) {
    set_has_set_to_default();
    node_.set_to_default_ = set_to_default;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.set_to_default)
}
inline ::pg_query::SetToDefault* Node::_internal_mutable_set_to_default() {
  if (!_internal_has_set_to_default()) {
    clear_node();
    set_has_set_to_default();
    node_.set_to_default_ = CreateMaybeMessage< ::pg_query::SetToDefault >(GetArena());
  }
  return node_.set_to_default_;
}
inline ::pg_query::SetToDefault* Node::mutable_set_to_default() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.set_to_default)
  return _internal_mutable_set_to_default();
}

// .pg_query.CurrentOfExpr current_of_expr = 43 [json_name = "CurrentOfExpr"];
inline bool Node::_internal_has_current_of_expr() const {
  return node_case() == kCurrentOfExpr;
}
inline bool Node::has_current_of_expr() const {
  return _internal_has_current_of_expr();
}
inline void Node::set_has_current_of_expr() {
  _oneof_case_[0] = kCurrentOfExpr;
}
inline void Node::clear_current_of_expr() {
  if (_internal_has_current_of_expr()) {
    if (GetArena() == nullptr) {
      delete node_.current_of_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CurrentOfExpr* Node::release_current_of_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.current_of_expr)
  if (_internal_has_current_of_expr()) {
    clear_has_node();
      ::pg_query::CurrentOfExpr* temp = node_.current_of_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.current_of_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CurrentOfExpr& Node::_internal_current_of_expr() const {
  return _internal_has_current_of_expr()
      ? *node_.current_of_expr_
      : reinterpret_cast< ::pg_query::CurrentOfExpr&>(::pg_query::_CurrentOfExpr_default_instance_);
}
inline const ::pg_query::CurrentOfExpr& Node::current_of_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.current_of_expr)
  return _internal_current_of_expr();
}
inline ::pg_query::CurrentOfExpr* Node::unsafe_arena_release_current_of_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.current_of_expr)
  if (_internal_has_current_of_expr()) {
    clear_has_node();
    ::pg_query::CurrentOfExpr* temp = node_.current_of_expr_;
    node_.current_of_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_current_of_expr(::pg_query::CurrentOfExpr* current_of_expr) {
  clear_node();
  if (current_of_expr) {
    set_has_current_of_expr();
    node_.current_of_expr_ = current_of_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.current_of_expr)
}
inline ::pg_query::CurrentOfExpr* Node::_internal_mutable_current_of_expr() {
  if (!_internal_has_current_of_expr()) {
    clear_node();
    set_has_current_of_expr();
    node_.current_of_expr_ = CreateMaybeMessage< ::pg_query::CurrentOfExpr >(GetArena());
  }
  return node_.current_of_expr_;
}
inline ::pg_query::CurrentOfExpr* Node::mutable_current_of_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.current_of_expr)
  return _internal_mutable_current_of_expr();
}

// .pg_query.NextValueExpr next_value_expr = 44 [json_name = "NextValueExpr"];
inline bool Node::_internal_has_next_value_expr() const {
  return node_case() == kNextValueExpr;
}
inline bool Node::has_next_value_expr() const {
  return _internal_has_next_value_expr();
}
inline void Node::set_has_next_value_expr() {
  _oneof_case_[0] = kNextValueExpr;
}
inline void Node::clear_next_value_expr() {
  if (_internal_has_next_value_expr()) {
    if (GetArena() == nullptr) {
      delete node_.next_value_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::NextValueExpr* Node::release_next_value_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.next_value_expr)
  if (_internal_has_next_value_expr()) {
    clear_has_node();
      ::pg_query::NextValueExpr* temp = node_.next_value_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.next_value_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::NextValueExpr& Node::_internal_next_value_expr() const {
  return _internal_has_next_value_expr()
      ? *node_.next_value_expr_
      : reinterpret_cast< ::pg_query::NextValueExpr&>(::pg_query::_NextValueExpr_default_instance_);
}
inline const ::pg_query::NextValueExpr& Node::next_value_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.next_value_expr)
  return _internal_next_value_expr();
}
inline ::pg_query::NextValueExpr* Node::unsafe_arena_release_next_value_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.next_value_expr)
  if (_internal_has_next_value_expr()) {
    clear_has_node();
    ::pg_query::NextValueExpr* temp = node_.next_value_expr_;
    node_.next_value_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_next_value_expr(::pg_query::NextValueExpr* next_value_expr) {
  clear_node();
  if (next_value_expr) {
    set_has_next_value_expr();
    node_.next_value_expr_ = next_value_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.next_value_expr)
}
inline ::pg_query::NextValueExpr* Node::_internal_mutable_next_value_expr() {
  if (!_internal_has_next_value_expr()) {
    clear_node();
    set_has_next_value_expr();
    node_.next_value_expr_ = CreateMaybeMessage< ::pg_query::NextValueExpr >(GetArena());
  }
  return node_.next_value_expr_;
}
inline ::pg_query::NextValueExpr* Node::mutable_next_value_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.next_value_expr)
  return _internal_mutable_next_value_expr();
}

// .pg_query.InferenceElem inference_elem = 45 [json_name = "InferenceElem"];
inline bool Node::_internal_has_inference_elem() const {
  return node_case() == kInferenceElem;
}
inline bool Node::has_inference_elem() const {
  return _internal_has_inference_elem();
}
inline void Node::set_has_inference_elem() {
  _oneof_case_[0] = kInferenceElem;
}
inline void Node::clear_inference_elem() {
  if (_internal_has_inference_elem()) {
    if (GetArena() == nullptr) {
      delete node_.inference_elem_;
    }
    clear_has_node();
  }
}
inline ::pg_query::InferenceElem* Node::release_inference_elem() {
  // @@protoc_insertion_point(field_release:pg_query.Node.inference_elem)
  if (_internal_has_inference_elem()) {
    clear_has_node();
      ::pg_query::InferenceElem* temp = node_.inference_elem_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.inference_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::InferenceElem& Node::_internal_inference_elem() const {
  return _internal_has_inference_elem()
      ? *node_.inference_elem_
      : reinterpret_cast< ::pg_query::InferenceElem&>(::pg_query::_InferenceElem_default_instance_);
}
inline const ::pg_query::InferenceElem& Node::inference_elem() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.inference_elem)
  return _internal_inference_elem();
}
inline ::pg_query::InferenceElem* Node::unsafe_arena_release_inference_elem() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.inference_elem)
  if (_internal_has_inference_elem()) {
    clear_has_node();
    ::pg_query::InferenceElem* temp = node_.inference_elem_;
    node_.inference_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_inference_elem(::pg_query::InferenceElem* inference_elem) {
  clear_node();
  if (inference_elem) {
    set_has_inference_elem();
    node_.inference_elem_ = inference_elem;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.inference_elem)
}
inline ::pg_query::InferenceElem* Node::_internal_mutable_inference_elem() {
  if (!_internal_has_inference_elem()) {
    clear_node();
    set_has_inference_elem();
    node_.inference_elem_ = CreateMaybeMessage< ::pg_query::InferenceElem >(GetArena());
  }
  return node_.inference_elem_;
}
inline ::pg_query::InferenceElem* Node::mutable_inference_elem() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.inference_elem)
  return _internal_mutable_inference_elem();
}

// .pg_query.TargetEntry target_entry = 46 [json_name = "TargetEntry"];
inline bool Node::_internal_has_target_entry() const {
  return node_case() == kTargetEntry;
}
inline bool Node::has_target_entry() const {
  return _internal_has_target_entry();
}
inline void Node::set_has_target_entry() {
  _oneof_case_[0] = kTargetEntry;
}
inline void Node::clear_target_entry() {
  if (_internal_has_target_entry()) {
    if (GetArena() == nullptr) {
      delete node_.target_entry_;
    }
    clear_has_node();
  }
}
inline ::pg_query::TargetEntry* Node::release_target_entry() {
  // @@protoc_insertion_point(field_release:pg_query.Node.target_entry)
  if (_internal_has_target_entry()) {
    clear_has_node();
      ::pg_query::TargetEntry* temp = node_.target_entry_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.target_entry_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TargetEntry& Node::_internal_target_entry() const {
  return _internal_has_target_entry()
      ? *node_.target_entry_
      : reinterpret_cast< ::pg_query::TargetEntry&>(::pg_query::_TargetEntry_default_instance_);
}
inline const ::pg_query::TargetEntry& Node::target_entry() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.target_entry)
  return _internal_target_entry();
}
inline ::pg_query::TargetEntry* Node::unsafe_arena_release_target_entry() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.target_entry)
  if (_internal_has_target_entry()) {
    clear_has_node();
    ::pg_query::TargetEntry* temp = node_.target_entry_;
    node_.target_entry_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_target_entry(::pg_query::TargetEntry* target_entry) {
  clear_node();
  if (target_entry) {
    set_has_target_entry();
    node_.target_entry_ = target_entry;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.target_entry)
}
inline ::pg_query::TargetEntry* Node::_internal_mutable_target_entry() {
  if (!_internal_has_target_entry()) {
    clear_node();
    set_has_target_entry();
    node_.target_entry_ = CreateMaybeMessage< ::pg_query::TargetEntry >(GetArena());
  }
  return node_.target_entry_;
}
inline ::pg_query::TargetEntry* Node::mutable_target_entry() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.target_entry)
  return _internal_mutable_target_entry();
}

// .pg_query.RangeTblRef range_tbl_ref = 47 [json_name = "RangeTblRef"];
inline bool Node::_internal_has_range_tbl_ref() const {
  return node_case() == kRangeTblRef;
}
inline bool Node::has_range_tbl_ref() const {
  return _internal_has_range_tbl_ref();
}
inline void Node::set_has_range_tbl_ref() {
  _oneof_case_[0] = kRangeTblRef;
}
inline void Node::clear_range_tbl_ref() {
  if (_internal_has_range_tbl_ref()) {
    if (GetArena() == nullptr) {
      delete node_.range_tbl_ref_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RangeTblRef* Node::release_range_tbl_ref() {
  // @@protoc_insertion_point(field_release:pg_query.Node.range_tbl_ref)
  if (_internal_has_range_tbl_ref()) {
    clear_has_node();
      ::pg_query::RangeTblRef* temp = node_.range_tbl_ref_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.range_tbl_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeTblRef& Node::_internal_range_tbl_ref() const {
  return _internal_has_range_tbl_ref()
      ? *node_.range_tbl_ref_
      : reinterpret_cast< ::pg_query::RangeTblRef&>(::pg_query::_RangeTblRef_default_instance_);
}
inline const ::pg_query::RangeTblRef& Node::range_tbl_ref() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.range_tbl_ref)
  return _internal_range_tbl_ref();
}
inline ::pg_query::RangeTblRef* Node::unsafe_arena_release_range_tbl_ref() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_tbl_ref)
  if (_internal_has_range_tbl_ref()) {
    clear_has_node();
    ::pg_query::RangeTblRef* temp = node_.range_tbl_ref_;
    node_.range_tbl_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_tbl_ref(::pg_query::RangeTblRef* range_tbl_ref) {
  clear_node();
  if (range_tbl_ref) {
    set_has_range_tbl_ref();
    node_.range_tbl_ref_ = range_tbl_ref;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_tbl_ref)
}
inline ::pg_query::RangeTblRef* Node::_internal_mutable_range_tbl_ref() {
  if (!_internal_has_range_tbl_ref()) {
    clear_node();
    set_has_range_tbl_ref();
    node_.range_tbl_ref_ = CreateMaybeMessage< ::pg_query::RangeTblRef >(GetArena());
  }
  return node_.range_tbl_ref_;
}
inline ::pg_query::RangeTblRef* Node::mutable_range_tbl_ref() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_tbl_ref)
  return _internal_mutable_range_tbl_ref();
}

// .pg_query.JoinExpr join_expr = 48 [json_name = "JoinExpr"];
inline bool Node::_internal_has_join_expr() const {
  return node_case() == kJoinExpr;
}
inline bool Node::has_join_expr() const {
  return _internal_has_join_expr();
}
inline void Node::set_has_join_expr() {
  _oneof_case_[0] = kJoinExpr;
}
inline void Node::clear_join_expr() {
  if (_internal_has_join_expr()) {
    if (GetArena() == nullptr) {
      delete node_.join_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JoinExpr* Node::release_join_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.join_expr)
  if (_internal_has_join_expr()) {
    clear_has_node();
      ::pg_query::JoinExpr* temp = node_.join_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.join_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JoinExpr& Node::_internal_join_expr() const {
  return _internal_has_join_expr()
      ? *node_.join_expr_
      : reinterpret_cast< ::pg_query::JoinExpr&>(::pg_query::_JoinExpr_default_instance_);
}
inline const ::pg_query::JoinExpr& Node::join_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.join_expr)
  return _internal_join_expr();
}
inline ::pg_query::JoinExpr* Node::unsafe_arena_release_join_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.join_expr)
  if (_internal_has_join_expr()) {
    clear_has_node();
    ::pg_query::JoinExpr* temp = node_.join_expr_;
    node_.join_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_join_expr(::pg_query::JoinExpr* join_expr) {
  clear_node();
  if (join_expr) {
    set_has_join_expr();
    node_.join_expr_ = join_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.join_expr)
}
inline ::pg_query::JoinExpr* Node::_internal_mutable_join_expr() {
  if (!_internal_has_join_expr()) {
    clear_node();
    set_has_join_expr();
    node_.join_expr_ = CreateMaybeMessage< ::pg_query::JoinExpr >(GetArena());
  }
  return node_.join_expr_;
}
inline ::pg_query::JoinExpr* Node::mutable_join_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.join_expr)
  return _internal_mutable_join_expr();
}

// .pg_query.FromExpr from_expr = 49 [json_name = "FromExpr"];
inline bool Node::_internal_has_from_expr() const {
  return node_case() == kFromExpr;
}
inline bool Node::has_from_expr() const {
  return _internal_has_from_expr();
}
inline void Node::set_has_from_expr() {
  _oneof_case_[0] = kFromExpr;
}
inline void Node::clear_from_expr() {
  if (_internal_has_from_expr()) {
    if (GetArena() == nullptr) {
      delete node_.from_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::FromExpr* Node::release_from_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.from_expr)
  if (_internal_has_from_expr()) {
    clear_has_node();
      ::pg_query::FromExpr* temp = node_.from_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.from_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FromExpr& Node::_internal_from_expr() const {
  return _internal_has_from_expr()
      ? *node_.from_expr_
      : reinterpret_cast< ::pg_query::FromExpr&>(::pg_query::_FromExpr_default_instance_);
}
inline const ::pg_query::FromExpr& Node::from_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.from_expr)
  return _internal_from_expr();
}
inline ::pg_query::FromExpr* Node::unsafe_arena_release_from_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.from_expr)
  if (_internal_has_from_expr()) {
    clear_has_node();
    ::pg_query::FromExpr* temp = node_.from_expr_;
    node_.from_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_from_expr(::pg_query::FromExpr* from_expr) {
  clear_node();
  if (from_expr) {
    set_has_from_expr();
    node_.from_expr_ = from_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.from_expr)
}
inline ::pg_query::FromExpr* Node::_internal_mutable_from_expr() {
  if (!_internal_has_from_expr()) {
    clear_node();
    set_has_from_expr();
    node_.from_expr_ = CreateMaybeMessage< ::pg_query::FromExpr >(GetArena());
  }
  return node_.from_expr_;
}
inline ::pg_query::FromExpr* Node::mutable_from_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.from_expr)
  return _internal_mutable_from_expr();
}

// .pg_query.OnConflictExpr on_conflict_expr = 50 [json_name = "OnConflictExpr"];
inline bool Node::_internal_has_on_conflict_expr() const {
  return node_case() == kOnConflictExpr;
}
inline bool Node::has_on_conflict_expr() const {
  return _internal_has_on_conflict_expr();
}
inline void Node::set_has_on_conflict_expr() {
  _oneof_case_[0] = kOnConflictExpr;
}
inline void Node::clear_on_conflict_expr() {
  if (_internal_has_on_conflict_expr()) {
    if (GetArena() == nullptr) {
      delete node_.on_conflict_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::OnConflictExpr* Node::release_on_conflict_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.on_conflict_expr)
  if (_internal_has_on_conflict_expr()) {
    clear_has_node();
      ::pg_query::OnConflictExpr* temp = node_.on_conflict_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.on_conflict_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::OnConflictExpr& Node::_internal_on_conflict_expr() const {
  return _internal_has_on_conflict_expr()
      ? *node_.on_conflict_expr_
      : reinterpret_cast< ::pg_query::OnConflictExpr&>(::pg_query::_OnConflictExpr_default_instance_);
}
inline const ::pg_query::OnConflictExpr& Node::on_conflict_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.on_conflict_expr)
  return _internal_on_conflict_expr();
}
inline ::pg_query::OnConflictExpr* Node::unsafe_arena_release_on_conflict_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.on_conflict_expr)
  if (_internal_has_on_conflict_expr()) {
    clear_has_node();
    ::pg_query::OnConflictExpr* temp = node_.on_conflict_expr_;
    node_.on_conflict_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_on_conflict_expr(::pg_query::OnConflictExpr* on_conflict_expr) {
  clear_node();
  if (on_conflict_expr) {
    set_has_on_conflict_expr();
    node_.on_conflict_expr_ = on_conflict_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.on_conflict_expr)
}
inline ::pg_query::OnConflictExpr* Node::_internal_mutable_on_conflict_expr() {
  if (!_internal_has_on_conflict_expr()) {
    clear_node();
    set_has_on_conflict_expr();
    node_.on_conflict_expr_ = CreateMaybeMessage< ::pg_query::OnConflictExpr >(GetArena());
  }
  return node_.on_conflict_expr_;
}
inline ::pg_query::OnConflictExpr* Node::mutable_on_conflict_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.on_conflict_expr)
  return _internal_mutable_on_conflict_expr();
}

// .pg_query.IntoClause into_clause = 51 [json_name = "IntoClause"];
inline bool Node::_internal_has_into_clause() const {
  return node_case() == kIntoClause;
}
inline bool Node::has_into_clause() const {
  return _internal_has_into_clause();
}
inline void Node::set_has_into_clause() {
  _oneof_case_[0] = kIntoClause;
}
inline void Node::clear_into_clause() {
  if (_internal_has_into_clause()) {
    if (GetArena() == nullptr) {
      delete node_.into_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::IntoClause* Node::release_into_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.into_clause)
  if (_internal_has_into_clause()) {
    clear_has_node();
      ::pg_query::IntoClause* temp = node_.into_clause_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.into_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::IntoClause& Node::_internal_into_clause() const {
  return _internal_has_into_clause()
      ? *node_.into_clause_
      : reinterpret_cast< ::pg_query::IntoClause&>(::pg_query::_IntoClause_default_instance_);
}
inline const ::pg_query::IntoClause& Node::into_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.into_clause)
  return _internal_into_clause();
}
inline ::pg_query::IntoClause* Node::unsafe_arena_release_into_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.into_clause)
  if (_internal_has_into_clause()) {
    clear_has_node();
    ::pg_query::IntoClause* temp = node_.into_clause_;
    node_.into_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_into_clause(::pg_query::IntoClause* into_clause) {
  clear_node();
  if (into_clause) {
    set_has_into_clause();
    node_.into_clause_ = into_clause;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.into_clause)
}
inline ::pg_query::IntoClause* Node::_internal_mutable_into_clause() {
  if (!_internal_has_into_clause()) {
    clear_node();
    set_has_into_clause();
    node_.into_clause_ = CreateMaybeMessage< ::pg_query::IntoClause >(GetArena());
  }
  return node_.into_clause_;
}
inline ::pg_query::IntoClause* Node::mutable_into_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.into_clause)
  return _internal_mutable_into_clause();
}

// .pg_query.RawStmt raw_stmt = 52 [json_name = "RawStmt"];
inline bool Node::_internal_has_raw_stmt() const {
  return node_case() == kRawStmt;
}
inline bool Node::has_raw_stmt() const {
  return _internal_has_raw_stmt();
}
inline void Node::set_has_raw_stmt() {
  _oneof_case_[0] = kRawStmt;
}
inline void Node::clear_raw_stmt() {
  if (_internal_has_raw_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.raw_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RawStmt* Node::release_raw_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.raw_stmt)
  if (_internal_has_raw_stmt()) {
    clear_has_node();
      ::pg_query::RawStmt* temp = node_.raw_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.raw_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RawStmt& Node::_internal_raw_stmt() const {
  return _internal_has_raw_stmt()
      ? *node_.raw_stmt_
      : reinterpret_cast< ::pg_query::RawStmt&>(::pg_query::_RawStmt_default_instance_);
}
inline const ::pg_query::RawStmt& Node::raw_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.raw_stmt)
  return _internal_raw_stmt();
}
inline ::pg_query::RawStmt* Node::unsafe_arena_release_raw_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.raw_stmt)
  if (_internal_has_raw_stmt()) {
    clear_has_node();
    ::pg_query::RawStmt* temp = node_.raw_stmt_;
    node_.raw_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_raw_stmt(::pg_query::RawStmt* raw_stmt) {
  clear_node();
  if (raw_stmt) {
    set_has_raw_stmt();
    node_.raw_stmt_ = raw_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.raw_stmt)
}
inline ::pg_query::RawStmt* Node::_internal_mutable_raw_stmt() {
  if (!_internal_has_raw_stmt()) {
    clear_node();
    set_has_raw_stmt();
    node_.raw_stmt_ = CreateMaybeMessage< ::pg_query::RawStmt >(GetArena());
  }
  return node_.raw_stmt_;
}
inline ::pg_query::RawStmt* Node::mutable_raw_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.raw_stmt)
  return _internal_mutable_raw_stmt();
}

// .pg_query.Query query = 53 [json_name = "Query"];
inline bool Node::_internal_has_query() const {
  return node_case() == kQuery;
}
inline bool Node::has_query() const {
  return _internal_has_query();
}
inline void Node::set_has_query() {
  _oneof_case_[0] = kQuery;
}
inline void Node::clear_query() {
  if (_internal_has_query()) {
    if (GetArena() == nullptr) {
      delete node_.query_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Query* Node::release_query() {
  // @@protoc_insertion_point(field_release:pg_query.Node.query)
  if (_internal_has_query()) {
    clear_has_node();
      ::pg_query::Query* temp = node_.query_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Query& Node::_internal_query() const {
  return _internal_has_query()
      ? *node_.query_
      : reinterpret_cast< ::pg_query::Query&>(::pg_query::_Query_default_instance_);
}
inline const ::pg_query::Query& Node::query() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.query)
  return _internal_query();
}
inline ::pg_query::Query* Node::unsafe_arena_release_query() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.query)
  if (_internal_has_query()) {
    clear_has_node();
    ::pg_query::Query* temp = node_.query_;
    node_.query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_query(::pg_query::Query* query) {
  clear_node();
  if (query) {
    set_has_query();
    node_.query_ = query;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.query)
}
inline ::pg_query::Query* Node::_internal_mutable_query() {
  if (!_internal_has_query()) {
    clear_node();
    set_has_query();
    node_.query_ = CreateMaybeMessage< ::pg_query::Query >(GetArena());
  }
  return node_.query_;
}
inline ::pg_query::Query* Node::mutable_query() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.query)
  return _internal_mutable_query();
}

// .pg_query.InsertStmt insert_stmt = 54 [json_name = "InsertStmt"];
inline bool Node::_internal_has_insert_stmt() const {
  return node_case() == kInsertStmt;
}
inline bool Node::has_insert_stmt() const {
  return _internal_has_insert_stmt();
}
inline void Node::set_has_insert_stmt() {
  _oneof_case_[0] = kInsertStmt;
}
inline void Node::clear_insert_stmt() {
  if (_internal_has_insert_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.insert_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::InsertStmt* Node::release_insert_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.insert_stmt)
  if (_internal_has_insert_stmt()) {
    clear_has_node();
      ::pg_query::InsertStmt* temp = node_.insert_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.insert_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::InsertStmt& Node::_internal_insert_stmt() const {
  return _internal_has_insert_stmt()
      ? *node_.insert_stmt_
      : reinterpret_cast< ::pg_query::InsertStmt&>(::pg_query::_InsertStmt_default_instance_);
}
inline const ::pg_query::InsertStmt& Node::insert_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.insert_stmt)
  return _internal_insert_stmt();
}
inline ::pg_query::InsertStmt* Node::unsafe_arena_release_insert_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.insert_stmt)
  if (_internal_has_insert_stmt()) {
    clear_has_node();
    ::pg_query::InsertStmt* temp = node_.insert_stmt_;
    node_.insert_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_insert_stmt(::pg_query::InsertStmt* insert_stmt) {
  clear_node();
  if (insert_stmt) {
    set_has_insert_stmt();
    node_.insert_stmt_ = insert_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.insert_stmt)
}
inline ::pg_query::InsertStmt* Node::_internal_mutable_insert_stmt() {
  if (!_internal_has_insert_stmt()) {
    clear_node();
    set_has_insert_stmt();
    node_.insert_stmt_ = CreateMaybeMessage< ::pg_query::InsertStmt >(GetArena());
  }
  return node_.insert_stmt_;
}
inline ::pg_query::InsertStmt* Node::mutable_insert_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.insert_stmt)
  return _internal_mutable_insert_stmt();
}

// .pg_query.DeleteStmt delete_stmt = 55 [json_name = "DeleteStmt"];
inline bool Node::_internal_has_delete_stmt() const {
  return node_case() == kDeleteStmt;
}
inline bool Node::has_delete_stmt() const {
  return _internal_has_delete_stmt();
}
inline void Node::set_has_delete_stmt() {
  _oneof_case_[0] = kDeleteStmt;
}
inline void Node::clear_delete_stmt() {
  if (_internal_has_delete_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.delete_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DeleteStmt* Node::release_delete_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.delete_stmt)
  if (_internal_has_delete_stmt()) {
    clear_has_node();
      ::pg_query::DeleteStmt* temp = node_.delete_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.delete_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DeleteStmt& Node::_internal_delete_stmt() const {
  return _internal_has_delete_stmt()
      ? *node_.delete_stmt_
      : reinterpret_cast< ::pg_query::DeleteStmt&>(::pg_query::_DeleteStmt_default_instance_);
}
inline const ::pg_query::DeleteStmt& Node::delete_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.delete_stmt)
  return _internal_delete_stmt();
}
inline ::pg_query::DeleteStmt* Node::unsafe_arena_release_delete_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.delete_stmt)
  if (_internal_has_delete_stmt()) {
    clear_has_node();
    ::pg_query::DeleteStmt* temp = node_.delete_stmt_;
    node_.delete_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_delete_stmt(::pg_query::DeleteStmt* delete_stmt) {
  clear_node();
  if (delete_stmt) {
    set_has_delete_stmt();
    node_.delete_stmt_ = delete_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.delete_stmt)
}
inline ::pg_query::DeleteStmt* Node::_internal_mutable_delete_stmt() {
  if (!_internal_has_delete_stmt()) {
    clear_node();
    set_has_delete_stmt();
    node_.delete_stmt_ = CreateMaybeMessage< ::pg_query::DeleteStmt >(GetArena());
  }
  return node_.delete_stmt_;
}
inline ::pg_query::DeleteStmt* Node::mutable_delete_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.delete_stmt)
  return _internal_mutable_delete_stmt();
}

// .pg_query.UpdateStmt update_stmt = 56 [json_name = "UpdateStmt"];
inline bool Node::_internal_has_update_stmt() const {
  return node_case() == kUpdateStmt;
}
inline bool Node::has_update_stmt() const {
  return _internal_has_update_stmt();
}
inline void Node::set_has_update_stmt() {
  _oneof_case_[0] = kUpdateStmt;
}
inline void Node::clear_update_stmt() {
  if (_internal_has_update_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.update_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::UpdateStmt* Node::release_update_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.update_stmt)
  if (_internal_has_update_stmt()) {
    clear_has_node();
      ::pg_query::UpdateStmt* temp = node_.update_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.update_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::UpdateStmt& Node::_internal_update_stmt() const {
  return _internal_has_update_stmt()
      ? *node_.update_stmt_
      : reinterpret_cast< ::pg_query::UpdateStmt&>(::pg_query::_UpdateStmt_default_instance_);
}
inline const ::pg_query::UpdateStmt& Node::update_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.update_stmt)
  return _internal_update_stmt();
}
inline ::pg_query::UpdateStmt* Node::unsafe_arena_release_update_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.update_stmt)
  if (_internal_has_update_stmt()) {
    clear_has_node();
    ::pg_query::UpdateStmt* temp = node_.update_stmt_;
    node_.update_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_update_stmt(::pg_query::UpdateStmt* update_stmt) {
  clear_node();
  if (update_stmt) {
    set_has_update_stmt();
    node_.update_stmt_ = update_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.update_stmt)
}
inline ::pg_query::UpdateStmt* Node::_internal_mutable_update_stmt() {
  if (!_internal_has_update_stmt()) {
    clear_node();
    set_has_update_stmt();
    node_.update_stmt_ = CreateMaybeMessage< ::pg_query::UpdateStmt >(GetArena());
  }
  return node_.update_stmt_;
}
inline ::pg_query::UpdateStmt* Node::mutable_update_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.update_stmt)
  return _internal_mutable_update_stmt();
}

// .pg_query.SelectStmt select_stmt = 57 [json_name = "SelectStmt"];
inline bool Node::_internal_has_select_stmt() const {
  return node_case() == kSelectStmt;
}
inline bool Node::has_select_stmt() const {
  return _internal_has_select_stmt();
}
inline void Node::set_has_select_stmt() {
  _oneof_case_[0] = kSelectStmt;
}
inline void Node::clear_select_stmt() {
  if (_internal_has_select_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.select_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::SelectStmt* Node::release_select_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.select_stmt)
  if (_internal_has_select_stmt()) {
    clear_has_node();
      ::pg_query::SelectStmt* temp = node_.select_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.select_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SelectStmt& Node::_internal_select_stmt() const {
  return _internal_has_select_stmt()
      ? *node_.select_stmt_
      : reinterpret_cast< ::pg_query::SelectStmt&>(::pg_query::_SelectStmt_default_instance_);
}
inline const ::pg_query::SelectStmt& Node::select_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.select_stmt)
  return _internal_select_stmt();
}
inline ::pg_query::SelectStmt* Node::unsafe_arena_release_select_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.select_stmt)
  if (_internal_has_select_stmt()) {
    clear_has_node();
    ::pg_query::SelectStmt* temp = node_.select_stmt_;
    node_.select_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_select_stmt(::pg_query::SelectStmt* select_stmt) {
  clear_node();
  if (select_stmt) {
    set_has_select_stmt();
    node_.select_stmt_ = select_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.select_stmt)
}
inline ::pg_query::SelectStmt* Node::_internal_mutable_select_stmt() {
  if (!_internal_has_select_stmt()) {
    clear_node();
    set_has_select_stmt();
    node_.select_stmt_ = CreateMaybeMessage< ::pg_query::SelectStmt >(GetArena());
  }
  return node_.select_stmt_;
}
inline ::pg_query::SelectStmt* Node::mutable_select_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.select_stmt)
  return _internal_mutable_select_stmt();
}

// .pg_query.AlterTableStmt alter_table_stmt = 58 [json_name = "AlterTableStmt"];
inline bool Node::_internal_has_alter_table_stmt() const {
  return node_case() == kAlterTableStmt;
}
inline bool Node::has_alter_table_stmt() const {
  return _internal_has_alter_table_stmt();
}
inline void Node::set_has_alter_table_stmt() {
  _oneof_case_[0] = kAlterTableStmt;
}
inline void Node::clear_alter_table_stmt() {
  if (_internal_has_alter_table_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_table_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterTableStmt* Node::release_alter_table_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_table_stmt)
  if (_internal_has_alter_table_stmt()) {
    clear_has_node();
      ::pg_query::AlterTableStmt* temp = node_.alter_table_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_table_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterTableStmt& Node::_internal_alter_table_stmt() const {
  return _internal_has_alter_table_stmt()
      ? *node_.alter_table_stmt_
      : reinterpret_cast< ::pg_query::AlterTableStmt&>(::pg_query::_AlterTableStmt_default_instance_);
}
inline const ::pg_query::AlterTableStmt& Node::alter_table_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_table_stmt)
  return _internal_alter_table_stmt();
}
inline ::pg_query::AlterTableStmt* Node::unsafe_arena_release_alter_table_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_table_stmt)
  if (_internal_has_alter_table_stmt()) {
    clear_has_node();
    ::pg_query::AlterTableStmt* temp = node_.alter_table_stmt_;
    node_.alter_table_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_table_stmt(::pg_query::AlterTableStmt* alter_table_stmt) {
  clear_node();
  if (alter_table_stmt) {
    set_has_alter_table_stmt();
    node_.alter_table_stmt_ = alter_table_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_table_stmt)
}
inline ::pg_query::AlterTableStmt* Node::_internal_mutable_alter_table_stmt() {
  if (!_internal_has_alter_table_stmt()) {
    clear_node();
    set_has_alter_table_stmt();
    node_.alter_table_stmt_ = CreateMaybeMessage< ::pg_query::AlterTableStmt >(GetArena());
  }
  return node_.alter_table_stmt_;
}
inline ::pg_query::AlterTableStmt* Node::mutable_alter_table_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_table_stmt)
  return _internal_mutable_alter_table_stmt();
}

// .pg_query.AlterTableCmd alter_table_cmd = 59 [json_name = "AlterTableCmd"];
inline bool Node::_internal_has_alter_table_cmd() const {
  return node_case() == kAlterTableCmd;
}
inline bool Node::has_alter_table_cmd() const {
  return _internal_has_alter_table_cmd();
}
inline void Node::set_has_alter_table_cmd() {
  _oneof_case_[0] = kAlterTableCmd;
}
inline void Node::clear_alter_table_cmd() {
  if (_internal_has_alter_table_cmd()) {
    if (GetArena() == nullptr) {
      delete node_.alter_table_cmd_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterTableCmd* Node::release_alter_table_cmd() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_table_cmd)
  if (_internal_has_alter_table_cmd()) {
    clear_has_node();
      ::pg_query::AlterTableCmd* temp = node_.alter_table_cmd_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_table_cmd_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterTableCmd& Node::_internal_alter_table_cmd() const {
  return _internal_has_alter_table_cmd()
      ? *node_.alter_table_cmd_
      : reinterpret_cast< ::pg_query::AlterTableCmd&>(::pg_query::_AlterTableCmd_default_instance_);
}
inline const ::pg_query::AlterTableCmd& Node::alter_table_cmd() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_table_cmd)
  return _internal_alter_table_cmd();
}
inline ::pg_query::AlterTableCmd* Node::unsafe_arena_release_alter_table_cmd() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_table_cmd)
  if (_internal_has_alter_table_cmd()) {
    clear_has_node();
    ::pg_query::AlterTableCmd* temp = node_.alter_table_cmd_;
    node_.alter_table_cmd_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_table_cmd(::pg_query::AlterTableCmd* alter_table_cmd) {
  clear_node();
  if (alter_table_cmd) {
    set_has_alter_table_cmd();
    node_.alter_table_cmd_ = alter_table_cmd;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_table_cmd)
}
inline ::pg_query::AlterTableCmd* Node::_internal_mutable_alter_table_cmd() {
  if (!_internal_has_alter_table_cmd()) {
    clear_node();
    set_has_alter_table_cmd();
    node_.alter_table_cmd_ = CreateMaybeMessage< ::pg_query::AlterTableCmd >(GetArena());
  }
  return node_.alter_table_cmd_;
}
inline ::pg_query::AlterTableCmd* Node::mutable_alter_table_cmd() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_table_cmd)
  return _internal_mutable_alter_table_cmd();
}

// .pg_query.AlterDomainStmt alter_domain_stmt = 60 [json_name = "AlterDomainStmt"];
inline bool Node::_internal_has_alter_domain_stmt() const {
  return node_case() == kAlterDomainStmt;
}
inline bool Node::has_alter_domain_stmt() const {
  return _internal_has_alter_domain_stmt();
}
inline void Node::set_has_alter_domain_stmt() {
  _oneof_case_[0] = kAlterDomainStmt;
}
inline void Node::clear_alter_domain_stmt() {
  if (_internal_has_alter_domain_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_domain_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterDomainStmt* Node::release_alter_domain_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_domain_stmt)
  if (_internal_has_alter_domain_stmt()) {
    clear_has_node();
      ::pg_query::AlterDomainStmt* temp = node_.alter_domain_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_domain_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterDomainStmt& Node::_internal_alter_domain_stmt() const {
  return _internal_has_alter_domain_stmt()
      ? *node_.alter_domain_stmt_
      : reinterpret_cast< ::pg_query::AlterDomainStmt&>(::pg_query::_AlterDomainStmt_default_instance_);
}
inline const ::pg_query::AlterDomainStmt& Node::alter_domain_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_domain_stmt)
  return _internal_alter_domain_stmt();
}
inline ::pg_query::AlterDomainStmt* Node::unsafe_arena_release_alter_domain_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_domain_stmt)
  if (_internal_has_alter_domain_stmt()) {
    clear_has_node();
    ::pg_query::AlterDomainStmt* temp = node_.alter_domain_stmt_;
    node_.alter_domain_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_domain_stmt(::pg_query::AlterDomainStmt* alter_domain_stmt) {
  clear_node();
  if (alter_domain_stmt) {
    set_has_alter_domain_stmt();
    node_.alter_domain_stmt_ = alter_domain_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_domain_stmt)
}
inline ::pg_query::AlterDomainStmt* Node::_internal_mutable_alter_domain_stmt() {
  if (!_internal_has_alter_domain_stmt()) {
    clear_node();
    set_has_alter_domain_stmt();
    node_.alter_domain_stmt_ = CreateMaybeMessage< ::pg_query::AlterDomainStmt >(GetArena());
  }
  return node_.alter_domain_stmt_;
}
inline ::pg_query::AlterDomainStmt* Node::mutable_alter_domain_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_domain_stmt)
  return _internal_mutable_alter_domain_stmt();
}

// .pg_query.SetOperationStmt set_operation_stmt = 61 [json_name = "SetOperationStmt"];
inline bool Node::_internal_has_set_operation_stmt() const {
  return node_case() == kSetOperationStmt;
}
inline bool Node::has_set_operation_stmt() const {
  return _internal_has_set_operation_stmt();
}
inline void Node::set_has_set_operation_stmt() {
  _oneof_case_[0] = kSetOperationStmt;
}
inline void Node::clear_set_operation_stmt() {
  if (_internal_has_set_operation_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.set_operation_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::SetOperationStmt* Node::release_set_operation_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.set_operation_stmt)
  if (_internal_has_set_operation_stmt()) {
    clear_has_node();
      ::pg_query::SetOperationStmt* temp = node_.set_operation_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.set_operation_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SetOperationStmt& Node::_internal_set_operation_stmt() const {
  return _internal_has_set_operation_stmt()
      ? *node_.set_operation_stmt_
      : reinterpret_cast< ::pg_query::SetOperationStmt&>(::pg_query::_SetOperationStmt_default_instance_);
}
inline const ::pg_query::SetOperationStmt& Node::set_operation_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.set_operation_stmt)
  return _internal_set_operation_stmt();
}
inline ::pg_query::SetOperationStmt* Node::unsafe_arena_release_set_operation_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.set_operation_stmt)
  if (_internal_has_set_operation_stmt()) {
    clear_has_node();
    ::pg_query::SetOperationStmt* temp = node_.set_operation_stmt_;
    node_.set_operation_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_set_operation_stmt(::pg_query::SetOperationStmt* set_operation_stmt) {
  clear_node();
  if (set_operation_stmt) {
    set_has_set_operation_stmt();
    node_.set_operation_stmt_ = set_operation_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.set_operation_stmt)
}
inline ::pg_query::SetOperationStmt* Node::_internal_mutable_set_operation_stmt() {
  if (!_internal_has_set_operation_stmt()) {
    clear_node();
    set_has_set_operation_stmt();
    node_.set_operation_stmt_ = CreateMaybeMessage< ::pg_query::SetOperationStmt >(GetArena());
  }
  return node_.set_operation_stmt_;
}
inline ::pg_query::SetOperationStmt* Node::mutable_set_operation_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.set_operation_stmt)
  return _internal_mutable_set_operation_stmt();
}

// .pg_query.GrantStmt grant_stmt = 62 [json_name = "GrantStmt"];
inline bool Node::_internal_has_grant_stmt() const {
  return node_case() == kGrantStmt;
}
inline bool Node::has_grant_stmt() const {
  return _internal_has_grant_stmt();
}
inline void Node::set_has_grant_stmt() {
  _oneof_case_[0] = kGrantStmt;
}
inline void Node::clear_grant_stmt() {
  if (_internal_has_grant_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.grant_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::GrantStmt* Node::release_grant_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.grant_stmt)
  if (_internal_has_grant_stmt()) {
    clear_has_node();
      ::pg_query::GrantStmt* temp = node_.grant_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.grant_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::GrantStmt& Node::_internal_grant_stmt() const {
  return _internal_has_grant_stmt()
      ? *node_.grant_stmt_
      : reinterpret_cast< ::pg_query::GrantStmt&>(::pg_query::_GrantStmt_default_instance_);
}
inline const ::pg_query::GrantStmt& Node::grant_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.grant_stmt)
  return _internal_grant_stmt();
}
inline ::pg_query::GrantStmt* Node::unsafe_arena_release_grant_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.grant_stmt)
  if (_internal_has_grant_stmt()) {
    clear_has_node();
    ::pg_query::GrantStmt* temp = node_.grant_stmt_;
    node_.grant_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_grant_stmt(::pg_query::GrantStmt* grant_stmt) {
  clear_node();
  if (grant_stmt) {
    set_has_grant_stmt();
    node_.grant_stmt_ = grant_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.grant_stmt)
}
inline ::pg_query::GrantStmt* Node::_internal_mutable_grant_stmt() {
  if (!_internal_has_grant_stmt()) {
    clear_node();
    set_has_grant_stmt();
    node_.grant_stmt_ = CreateMaybeMessage< ::pg_query::GrantStmt >(GetArena());
  }
  return node_.grant_stmt_;
}
inline ::pg_query::GrantStmt* Node::mutable_grant_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.grant_stmt)
  return _internal_mutable_grant_stmt();
}

// .pg_query.GrantRoleStmt grant_role_stmt = 63 [json_name = "GrantRoleStmt"];
inline bool Node::_internal_has_grant_role_stmt() const {
  return node_case() == kGrantRoleStmt;
}
inline bool Node::has_grant_role_stmt() const {
  return _internal_has_grant_role_stmt();
}
inline void Node::set_has_grant_role_stmt() {
  _oneof_case_[0] = kGrantRoleStmt;
}
inline void Node::clear_grant_role_stmt() {
  if (_internal_has_grant_role_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.grant_role_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::GrantRoleStmt* Node::release_grant_role_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.grant_role_stmt)
  if (_internal_has_grant_role_stmt()) {
    clear_has_node();
      ::pg_query::GrantRoleStmt* temp = node_.grant_role_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.grant_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::GrantRoleStmt& Node::_internal_grant_role_stmt() const {
  return _internal_has_grant_role_stmt()
      ? *node_.grant_role_stmt_
      : reinterpret_cast< ::pg_query::GrantRoleStmt&>(::pg_query::_GrantRoleStmt_default_instance_);
}
inline const ::pg_query::GrantRoleStmt& Node::grant_role_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.grant_role_stmt)
  return _internal_grant_role_stmt();
}
inline ::pg_query::GrantRoleStmt* Node::unsafe_arena_release_grant_role_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.grant_role_stmt)
  if (_internal_has_grant_role_stmt()) {
    clear_has_node();
    ::pg_query::GrantRoleStmt* temp = node_.grant_role_stmt_;
    node_.grant_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_grant_role_stmt(::pg_query::GrantRoleStmt* grant_role_stmt) {
  clear_node();
  if (grant_role_stmt) {
    set_has_grant_role_stmt();
    node_.grant_role_stmt_ = grant_role_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.grant_role_stmt)
}
inline ::pg_query::GrantRoleStmt* Node::_internal_mutable_grant_role_stmt() {
  if (!_internal_has_grant_role_stmt()) {
    clear_node();
    set_has_grant_role_stmt();
    node_.grant_role_stmt_ = CreateMaybeMessage< ::pg_query::GrantRoleStmt >(GetArena());
  }
  return node_.grant_role_stmt_;
}
inline ::pg_query::GrantRoleStmt* Node::mutable_grant_role_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.grant_role_stmt)
  return _internal_mutable_grant_role_stmt();
}

// .pg_query.AlterDefaultPrivilegesStmt alter_default_privileges_stmt = 64 [json_name = "AlterDefaultPrivilegesStmt"];
inline bool Node::_internal_has_alter_default_privileges_stmt() const {
  return node_case() == kAlterDefaultPrivilegesStmt;
}
inline bool Node::has_alter_default_privileges_stmt() const {
  return _internal_has_alter_default_privileges_stmt();
}
inline void Node::set_has_alter_default_privileges_stmt() {
  _oneof_case_[0] = kAlterDefaultPrivilegesStmt;
}
inline void Node::clear_alter_default_privileges_stmt() {
  if (_internal_has_alter_default_privileges_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_default_privileges_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterDefaultPrivilegesStmt* Node::release_alter_default_privileges_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_default_privileges_stmt)
  if (_internal_has_alter_default_privileges_stmt()) {
    clear_has_node();
      ::pg_query::AlterDefaultPrivilegesStmt* temp = node_.alter_default_privileges_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_default_privileges_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterDefaultPrivilegesStmt& Node::_internal_alter_default_privileges_stmt() const {
  return _internal_has_alter_default_privileges_stmt()
      ? *node_.alter_default_privileges_stmt_
      : reinterpret_cast< ::pg_query::AlterDefaultPrivilegesStmt&>(::pg_query::_AlterDefaultPrivilegesStmt_default_instance_);
}
inline const ::pg_query::AlterDefaultPrivilegesStmt& Node::alter_default_privileges_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_default_privileges_stmt)
  return _internal_alter_default_privileges_stmt();
}
inline ::pg_query::AlterDefaultPrivilegesStmt* Node::unsafe_arena_release_alter_default_privileges_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_default_privileges_stmt)
  if (_internal_has_alter_default_privileges_stmt()) {
    clear_has_node();
    ::pg_query::AlterDefaultPrivilegesStmt* temp = node_.alter_default_privileges_stmt_;
    node_.alter_default_privileges_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_default_privileges_stmt(::pg_query::AlterDefaultPrivilegesStmt* alter_default_privileges_stmt) {
  clear_node();
  if (alter_default_privileges_stmt) {
    set_has_alter_default_privileges_stmt();
    node_.alter_default_privileges_stmt_ = alter_default_privileges_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_default_privileges_stmt)
}
inline ::pg_query::AlterDefaultPrivilegesStmt* Node::_internal_mutable_alter_default_privileges_stmt() {
  if (!_internal_has_alter_default_privileges_stmt()) {
    clear_node();
    set_has_alter_default_privileges_stmt();
    node_.alter_default_privileges_stmt_ = CreateMaybeMessage< ::pg_query::AlterDefaultPrivilegesStmt >(GetArena());
  }
  return node_.alter_default_privileges_stmt_;
}
inline ::pg_query::AlterDefaultPrivilegesStmt* Node::mutable_alter_default_privileges_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_default_privileges_stmt)
  return _internal_mutable_alter_default_privileges_stmt();
}

// .pg_query.ClosePortalStmt close_portal_stmt = 65 [json_name = "ClosePortalStmt"];
inline bool Node::_internal_has_close_portal_stmt() const {
  return node_case() == kClosePortalStmt;
}
inline bool Node::has_close_portal_stmt() const {
  return _internal_has_close_portal_stmt();
}
inline void Node::set_has_close_portal_stmt() {
  _oneof_case_[0] = kClosePortalStmt;
}
inline void Node::clear_close_portal_stmt() {
  if (_internal_has_close_portal_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.close_portal_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ClosePortalStmt* Node::release_close_portal_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.close_portal_stmt)
  if (_internal_has_close_portal_stmt()) {
    clear_has_node();
      ::pg_query::ClosePortalStmt* temp = node_.close_portal_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.close_portal_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ClosePortalStmt& Node::_internal_close_portal_stmt() const {
  return _internal_has_close_portal_stmt()
      ? *node_.close_portal_stmt_
      : reinterpret_cast< ::pg_query::ClosePortalStmt&>(::pg_query::_ClosePortalStmt_default_instance_);
}
inline const ::pg_query::ClosePortalStmt& Node::close_portal_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.close_portal_stmt)
  return _internal_close_portal_stmt();
}
inline ::pg_query::ClosePortalStmt* Node::unsafe_arena_release_close_portal_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.close_portal_stmt)
  if (_internal_has_close_portal_stmt()) {
    clear_has_node();
    ::pg_query::ClosePortalStmt* temp = node_.close_portal_stmt_;
    node_.close_portal_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_close_portal_stmt(::pg_query::ClosePortalStmt* close_portal_stmt) {
  clear_node();
  if (close_portal_stmt) {
    set_has_close_portal_stmt();
    node_.close_portal_stmt_ = close_portal_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.close_portal_stmt)
}
inline ::pg_query::ClosePortalStmt* Node::_internal_mutable_close_portal_stmt() {
  if (!_internal_has_close_portal_stmt()) {
    clear_node();
    set_has_close_portal_stmt();
    node_.close_portal_stmt_ = CreateMaybeMessage< ::pg_query::ClosePortalStmt >(GetArena());
  }
  return node_.close_portal_stmt_;
}
inline ::pg_query::ClosePortalStmt* Node::mutable_close_portal_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.close_portal_stmt)
  return _internal_mutable_close_portal_stmt();
}

// .pg_query.ClusterStmt cluster_stmt = 66 [json_name = "ClusterStmt"];
inline bool Node::_internal_has_cluster_stmt() const {
  return node_case() == kClusterStmt;
}
inline bool Node::has_cluster_stmt() const {
  return _internal_has_cluster_stmt();
}
inline void Node::set_has_cluster_stmt() {
  _oneof_case_[0] = kClusterStmt;
}
inline void Node::clear_cluster_stmt() {
  if (_internal_has_cluster_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.cluster_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ClusterStmt* Node::release_cluster_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.cluster_stmt)
  if (_internal_has_cluster_stmt()) {
    clear_has_node();
      ::pg_query::ClusterStmt* temp = node_.cluster_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.cluster_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ClusterStmt& Node::_internal_cluster_stmt() const {
  return _internal_has_cluster_stmt()
      ? *node_.cluster_stmt_
      : reinterpret_cast< ::pg_query::ClusterStmt&>(::pg_query::_ClusterStmt_default_instance_);
}
inline const ::pg_query::ClusterStmt& Node::cluster_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.cluster_stmt)
  return _internal_cluster_stmt();
}
inline ::pg_query::ClusterStmt* Node::unsafe_arena_release_cluster_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.cluster_stmt)
  if (_internal_has_cluster_stmt()) {
    clear_has_node();
    ::pg_query::ClusterStmt* temp = node_.cluster_stmt_;
    node_.cluster_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_cluster_stmt(::pg_query::ClusterStmt* cluster_stmt) {
  clear_node();
  if (cluster_stmt) {
    set_has_cluster_stmt();
    node_.cluster_stmt_ = cluster_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.cluster_stmt)
}
inline ::pg_query::ClusterStmt* Node::_internal_mutable_cluster_stmt() {
  if (!_internal_has_cluster_stmt()) {
    clear_node();
    set_has_cluster_stmt();
    node_.cluster_stmt_ = CreateMaybeMessage< ::pg_query::ClusterStmt >(GetArena());
  }
  return node_.cluster_stmt_;
}
inline ::pg_query::ClusterStmt* Node::mutable_cluster_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.cluster_stmt)
  return _internal_mutable_cluster_stmt();
}

// .pg_query.CopyStmt copy_stmt = 67 [json_name = "CopyStmt"];
inline bool Node::_internal_has_copy_stmt() const {
  return node_case() == kCopyStmt;
}
inline bool Node::has_copy_stmt() const {
  return _internal_has_copy_stmt();
}
inline void Node::set_has_copy_stmt() {
  _oneof_case_[0] = kCopyStmt;
}
inline void Node::clear_copy_stmt() {
  if (_internal_has_copy_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.copy_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CopyStmt* Node::release_copy_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.copy_stmt)
  if (_internal_has_copy_stmt()) {
    clear_has_node();
      ::pg_query::CopyStmt* temp = node_.copy_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.copy_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CopyStmt& Node::_internal_copy_stmt() const {
  return _internal_has_copy_stmt()
      ? *node_.copy_stmt_
      : reinterpret_cast< ::pg_query::CopyStmt&>(::pg_query::_CopyStmt_default_instance_);
}
inline const ::pg_query::CopyStmt& Node::copy_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.copy_stmt)
  return _internal_copy_stmt();
}
inline ::pg_query::CopyStmt* Node::unsafe_arena_release_copy_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.copy_stmt)
  if (_internal_has_copy_stmt()) {
    clear_has_node();
    ::pg_query::CopyStmt* temp = node_.copy_stmt_;
    node_.copy_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_copy_stmt(::pg_query::CopyStmt* copy_stmt) {
  clear_node();
  if (copy_stmt) {
    set_has_copy_stmt();
    node_.copy_stmt_ = copy_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.copy_stmt)
}
inline ::pg_query::CopyStmt* Node::_internal_mutable_copy_stmt() {
  if (!_internal_has_copy_stmt()) {
    clear_node();
    set_has_copy_stmt();
    node_.copy_stmt_ = CreateMaybeMessage< ::pg_query::CopyStmt >(GetArena());
  }
  return node_.copy_stmt_;
}
inline ::pg_query::CopyStmt* Node::mutable_copy_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.copy_stmt)
  return _internal_mutable_copy_stmt();
}

// .pg_query.CreateStmt create_stmt = 68 [json_name = "CreateStmt"];
inline bool Node::_internal_has_create_stmt() const {
  return node_case() == kCreateStmt;
}
inline bool Node::has_create_stmt() const {
  return _internal_has_create_stmt();
}
inline void Node::set_has_create_stmt() {
  _oneof_case_[0] = kCreateStmt;
}
inline void Node::clear_create_stmt() {
  if (_internal_has_create_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateStmt* Node::release_create_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_stmt)
  if (_internal_has_create_stmt()) {
    clear_has_node();
      ::pg_query::CreateStmt* temp = node_.create_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateStmt& Node::_internal_create_stmt() const {
  return _internal_has_create_stmt()
      ? *node_.create_stmt_
      : reinterpret_cast< ::pg_query::CreateStmt&>(::pg_query::_CreateStmt_default_instance_);
}
inline const ::pg_query::CreateStmt& Node::create_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_stmt)
  return _internal_create_stmt();
}
inline ::pg_query::CreateStmt* Node::unsafe_arena_release_create_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_stmt)
  if (_internal_has_create_stmt()) {
    clear_has_node();
    ::pg_query::CreateStmt* temp = node_.create_stmt_;
    node_.create_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_stmt(::pg_query::CreateStmt* create_stmt) {
  clear_node();
  if (create_stmt) {
    set_has_create_stmt();
    node_.create_stmt_ = create_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_stmt)
}
inline ::pg_query::CreateStmt* Node::_internal_mutable_create_stmt() {
  if (!_internal_has_create_stmt()) {
    clear_node();
    set_has_create_stmt();
    node_.create_stmt_ = CreateMaybeMessage< ::pg_query::CreateStmt >(GetArena());
  }
  return node_.create_stmt_;
}
inline ::pg_query::CreateStmt* Node::mutable_create_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_stmt)
  return _internal_mutable_create_stmt();
}

// .pg_query.DefineStmt define_stmt = 69 [json_name = "DefineStmt"];
inline bool Node::_internal_has_define_stmt() const {
  return node_case() == kDefineStmt;
}
inline bool Node::has_define_stmt() const {
  return _internal_has_define_stmt();
}
inline void Node::set_has_define_stmt() {
  _oneof_case_[0] = kDefineStmt;
}
inline void Node::clear_define_stmt() {
  if (_internal_has_define_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.define_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DefineStmt* Node::release_define_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.define_stmt)
  if (_internal_has_define_stmt()) {
    clear_has_node();
      ::pg_query::DefineStmt* temp = node_.define_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.define_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DefineStmt& Node::_internal_define_stmt() const {
  return _internal_has_define_stmt()
      ? *node_.define_stmt_
      : reinterpret_cast< ::pg_query::DefineStmt&>(::pg_query::_DefineStmt_default_instance_);
}
inline const ::pg_query::DefineStmt& Node::define_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.define_stmt)
  return _internal_define_stmt();
}
inline ::pg_query::DefineStmt* Node::unsafe_arena_release_define_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.define_stmt)
  if (_internal_has_define_stmt()) {
    clear_has_node();
    ::pg_query::DefineStmt* temp = node_.define_stmt_;
    node_.define_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_define_stmt(::pg_query::DefineStmt* define_stmt) {
  clear_node();
  if (define_stmt) {
    set_has_define_stmt();
    node_.define_stmt_ = define_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.define_stmt)
}
inline ::pg_query::DefineStmt* Node::_internal_mutable_define_stmt() {
  if (!_internal_has_define_stmt()) {
    clear_node();
    set_has_define_stmt();
    node_.define_stmt_ = CreateMaybeMessage< ::pg_query::DefineStmt >(GetArena());
  }
  return node_.define_stmt_;
}
inline ::pg_query::DefineStmt* Node::mutable_define_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.define_stmt)
  return _internal_mutable_define_stmt();
}

// .pg_query.DropStmt drop_stmt = 70 [json_name = "DropStmt"];
inline bool Node::_internal_has_drop_stmt() const {
  return node_case() == kDropStmt;
}
inline bool Node::has_drop_stmt() const {
  return _internal_has_drop_stmt();
}
inline void Node::set_has_drop_stmt() {
  _oneof_case_[0] = kDropStmt;
}
inline void Node::clear_drop_stmt() {
  if (_internal_has_drop_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.drop_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DropStmt* Node::release_drop_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.drop_stmt)
  if (_internal_has_drop_stmt()) {
    clear_has_node();
      ::pg_query::DropStmt* temp = node_.drop_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.drop_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropStmt& Node::_internal_drop_stmt() const {
  return _internal_has_drop_stmt()
      ? *node_.drop_stmt_
      : reinterpret_cast< ::pg_query::DropStmt&>(::pg_query::_DropStmt_default_instance_);
}
inline const ::pg_query::DropStmt& Node::drop_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.drop_stmt)
  return _internal_drop_stmt();
}
inline ::pg_query::DropStmt* Node::unsafe_arena_release_drop_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.drop_stmt)
  if (_internal_has_drop_stmt()) {
    clear_has_node();
    ::pg_query::DropStmt* temp = node_.drop_stmt_;
    node_.drop_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_drop_stmt(::pg_query::DropStmt* drop_stmt) {
  clear_node();
  if (drop_stmt) {
    set_has_drop_stmt();
    node_.drop_stmt_ = drop_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.drop_stmt)
}
inline ::pg_query::DropStmt* Node::_internal_mutable_drop_stmt() {
  if (!_internal_has_drop_stmt()) {
    clear_node();
    set_has_drop_stmt();
    node_.drop_stmt_ = CreateMaybeMessage< ::pg_query::DropStmt >(GetArena());
  }
  return node_.drop_stmt_;
}
inline ::pg_query::DropStmt* Node::mutable_drop_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_stmt)
  return _internal_mutable_drop_stmt();
}

// .pg_query.TruncateStmt truncate_stmt = 71 [json_name = "TruncateStmt"];
inline bool Node::_internal_has_truncate_stmt() const {
  return node_case() == kTruncateStmt;
}
inline bool Node::has_truncate_stmt() const {
  return _internal_has_truncate_stmt();
}
inline void Node::set_has_truncate_stmt() {
  _oneof_case_[0] = kTruncateStmt;
}
inline void Node::clear_truncate_stmt() {
  if (_internal_has_truncate_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.truncate_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::TruncateStmt* Node::release_truncate_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.truncate_stmt)
  if (_internal_has_truncate_stmt()) {
    clear_has_node();
      ::pg_query::TruncateStmt* temp = node_.truncate_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.truncate_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TruncateStmt& Node::_internal_truncate_stmt() const {
  return _internal_has_truncate_stmt()
      ? *node_.truncate_stmt_
      : reinterpret_cast< ::pg_query::TruncateStmt&>(::pg_query::_TruncateStmt_default_instance_);
}
inline const ::pg_query::TruncateStmt& Node::truncate_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.truncate_stmt)
  return _internal_truncate_stmt();
}
inline ::pg_query::TruncateStmt* Node::unsafe_arena_release_truncate_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.truncate_stmt)
  if (_internal_has_truncate_stmt()) {
    clear_has_node();
    ::pg_query::TruncateStmt* temp = node_.truncate_stmt_;
    node_.truncate_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_truncate_stmt(::pg_query::TruncateStmt* truncate_stmt) {
  clear_node();
  if (truncate_stmt) {
    set_has_truncate_stmt();
    node_.truncate_stmt_ = truncate_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.truncate_stmt)
}
inline ::pg_query::TruncateStmt* Node::_internal_mutable_truncate_stmt() {
  if (!_internal_has_truncate_stmt()) {
    clear_node();
    set_has_truncate_stmt();
    node_.truncate_stmt_ = CreateMaybeMessage< ::pg_query::TruncateStmt >(GetArena());
  }
  return node_.truncate_stmt_;
}
inline ::pg_query::TruncateStmt* Node::mutable_truncate_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.truncate_stmt)
  return _internal_mutable_truncate_stmt();
}

// .pg_query.CommentStmt comment_stmt = 72 [json_name = "CommentStmt"];
inline bool Node::_internal_has_comment_stmt() const {
  return node_case() == kCommentStmt;
}
inline bool Node::has_comment_stmt() const {
  return _internal_has_comment_stmt();
}
inline void Node::set_has_comment_stmt() {
  _oneof_case_[0] = kCommentStmt;
}
inline void Node::clear_comment_stmt() {
  if (_internal_has_comment_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.comment_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CommentStmt* Node::release_comment_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.comment_stmt)
  if (_internal_has_comment_stmt()) {
    clear_has_node();
      ::pg_query::CommentStmt* temp = node_.comment_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.comment_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CommentStmt& Node::_internal_comment_stmt() const {
  return _internal_has_comment_stmt()
      ? *node_.comment_stmt_
      : reinterpret_cast< ::pg_query::CommentStmt&>(::pg_query::_CommentStmt_default_instance_);
}
inline const ::pg_query::CommentStmt& Node::comment_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.comment_stmt)
  return _internal_comment_stmt();
}
inline ::pg_query::CommentStmt* Node::unsafe_arena_release_comment_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.comment_stmt)
  if (_internal_has_comment_stmt()) {
    clear_has_node();
    ::pg_query::CommentStmt* temp = node_.comment_stmt_;
    node_.comment_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_comment_stmt(::pg_query::CommentStmt* comment_stmt) {
  clear_node();
  if (comment_stmt) {
    set_has_comment_stmt();
    node_.comment_stmt_ = comment_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.comment_stmt)
}
inline ::pg_query::CommentStmt* Node::_internal_mutable_comment_stmt() {
  if (!_internal_has_comment_stmt()) {
    clear_node();
    set_has_comment_stmt();
    node_.comment_stmt_ = CreateMaybeMessage< ::pg_query::CommentStmt >(GetArena());
  }
  return node_.comment_stmt_;
}
inline ::pg_query::CommentStmt* Node::mutable_comment_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.comment_stmt)
  return _internal_mutable_comment_stmt();
}

// .pg_query.FetchStmt fetch_stmt = 73 [json_name = "FetchStmt"];
inline bool Node::_internal_has_fetch_stmt() const {
  return node_case() == kFetchStmt;
}
inline bool Node::has_fetch_stmt() const {
  return _internal_has_fetch_stmt();
}
inline void Node::set_has_fetch_stmt() {
  _oneof_case_[0] = kFetchStmt;
}
inline void Node::clear_fetch_stmt() {
  if (_internal_has_fetch_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.fetch_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::FetchStmt* Node::release_fetch_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.fetch_stmt)
  if (_internal_has_fetch_stmt()) {
    clear_has_node();
      ::pg_query::FetchStmt* temp = node_.fetch_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.fetch_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FetchStmt& Node::_internal_fetch_stmt() const {
  return _internal_has_fetch_stmt()
      ? *node_.fetch_stmt_
      : reinterpret_cast< ::pg_query::FetchStmt&>(::pg_query::_FetchStmt_default_instance_);
}
inline const ::pg_query::FetchStmt& Node::fetch_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.fetch_stmt)
  return _internal_fetch_stmt();
}
inline ::pg_query::FetchStmt* Node::unsafe_arena_release_fetch_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.fetch_stmt)
  if (_internal_has_fetch_stmt()) {
    clear_has_node();
    ::pg_query::FetchStmt* temp = node_.fetch_stmt_;
    node_.fetch_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_fetch_stmt(::pg_query::FetchStmt* fetch_stmt) {
  clear_node();
  if (fetch_stmt) {
    set_has_fetch_stmt();
    node_.fetch_stmt_ = fetch_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.fetch_stmt)
}
inline ::pg_query::FetchStmt* Node::_internal_mutable_fetch_stmt() {
  if (!_internal_has_fetch_stmt()) {
    clear_node();
    set_has_fetch_stmt();
    node_.fetch_stmt_ = CreateMaybeMessage< ::pg_query::FetchStmt >(GetArena());
  }
  return node_.fetch_stmt_;
}
inline ::pg_query::FetchStmt* Node::mutable_fetch_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.fetch_stmt)
  return _internal_mutable_fetch_stmt();
}

// .pg_query.IndexStmt index_stmt = 74 [json_name = "IndexStmt"];
inline bool Node::_internal_has_index_stmt() const {
  return node_case() == kIndexStmt;
}
inline bool Node::has_index_stmt() const {
  return _internal_has_index_stmt();
}
inline void Node::set_has_index_stmt() {
  _oneof_case_[0] = kIndexStmt;
}
inline void Node::clear_index_stmt() {
  if (_internal_has_index_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.index_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::IndexStmt* Node::release_index_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.index_stmt)
  if (_internal_has_index_stmt()) {
    clear_has_node();
      ::pg_query::IndexStmt* temp = node_.index_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.index_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::IndexStmt& Node::_internal_index_stmt() const {
  return _internal_has_index_stmt()
      ? *node_.index_stmt_
      : reinterpret_cast< ::pg_query::IndexStmt&>(::pg_query::_IndexStmt_default_instance_);
}
inline const ::pg_query::IndexStmt& Node::index_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.index_stmt)
  return _internal_index_stmt();
}
inline ::pg_query::IndexStmt* Node::unsafe_arena_release_index_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.index_stmt)
  if (_internal_has_index_stmt()) {
    clear_has_node();
    ::pg_query::IndexStmt* temp = node_.index_stmt_;
    node_.index_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_index_stmt(::pg_query::IndexStmt* index_stmt) {
  clear_node();
  if (index_stmt) {
    set_has_index_stmt();
    node_.index_stmt_ = index_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.index_stmt)
}
inline ::pg_query::IndexStmt* Node::_internal_mutable_index_stmt() {
  if (!_internal_has_index_stmt()) {
    clear_node();
    set_has_index_stmt();
    node_.index_stmt_ = CreateMaybeMessage< ::pg_query::IndexStmt >(GetArena());
  }
  return node_.index_stmt_;
}
inline ::pg_query::IndexStmt* Node::mutable_index_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.index_stmt)
  return _internal_mutable_index_stmt();
}

// .pg_query.CreateFunctionStmt create_function_stmt = 75 [json_name = "CreateFunctionStmt"];
inline bool Node::_internal_has_create_function_stmt() const {
  return node_case() == kCreateFunctionStmt;
}
inline bool Node::has_create_function_stmt() const {
  return _internal_has_create_function_stmt();
}
inline void Node::set_has_create_function_stmt() {
  _oneof_case_[0] = kCreateFunctionStmt;
}
inline void Node::clear_create_function_stmt() {
  if (_internal_has_create_function_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_function_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateFunctionStmt* Node::release_create_function_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_function_stmt)
  if (_internal_has_create_function_stmt()) {
    clear_has_node();
      ::pg_query::CreateFunctionStmt* temp = node_.create_function_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_function_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateFunctionStmt& Node::_internal_create_function_stmt() const {
  return _internal_has_create_function_stmt()
      ? *node_.create_function_stmt_
      : reinterpret_cast< ::pg_query::CreateFunctionStmt&>(::pg_query::_CreateFunctionStmt_default_instance_);
}
inline const ::pg_query::CreateFunctionStmt& Node::create_function_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_function_stmt)
  return _internal_create_function_stmt();
}
inline ::pg_query::CreateFunctionStmt* Node::unsafe_arena_release_create_function_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_function_stmt)
  if (_internal_has_create_function_stmt()) {
    clear_has_node();
    ::pg_query::CreateFunctionStmt* temp = node_.create_function_stmt_;
    node_.create_function_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_function_stmt(::pg_query::CreateFunctionStmt* create_function_stmt) {
  clear_node();
  if (create_function_stmt) {
    set_has_create_function_stmt();
    node_.create_function_stmt_ = create_function_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_function_stmt)
}
inline ::pg_query::CreateFunctionStmt* Node::_internal_mutable_create_function_stmt() {
  if (!_internal_has_create_function_stmt()) {
    clear_node();
    set_has_create_function_stmt();
    node_.create_function_stmt_ = CreateMaybeMessage< ::pg_query::CreateFunctionStmt >(GetArena());
  }
  return node_.create_function_stmt_;
}
inline ::pg_query::CreateFunctionStmt* Node::mutable_create_function_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_function_stmt)
  return _internal_mutable_create_function_stmt();
}

// .pg_query.AlterFunctionStmt alter_function_stmt = 76 [json_name = "AlterFunctionStmt"];
inline bool Node::_internal_has_alter_function_stmt() const {
  return node_case() == kAlterFunctionStmt;
}
inline bool Node::has_alter_function_stmt() const {
  return _internal_has_alter_function_stmt();
}
inline void Node::set_has_alter_function_stmt() {
  _oneof_case_[0] = kAlterFunctionStmt;
}
inline void Node::clear_alter_function_stmt() {
  if (_internal_has_alter_function_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_function_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterFunctionStmt* Node::release_alter_function_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_function_stmt)
  if (_internal_has_alter_function_stmt()) {
    clear_has_node();
      ::pg_query::AlterFunctionStmt* temp = node_.alter_function_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_function_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterFunctionStmt& Node::_internal_alter_function_stmt() const {
  return _internal_has_alter_function_stmt()
      ? *node_.alter_function_stmt_
      : reinterpret_cast< ::pg_query::AlterFunctionStmt&>(::pg_query::_AlterFunctionStmt_default_instance_);
}
inline const ::pg_query::AlterFunctionStmt& Node::alter_function_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_function_stmt)
  return _internal_alter_function_stmt();
}
inline ::pg_query::AlterFunctionStmt* Node::unsafe_arena_release_alter_function_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_function_stmt)
  if (_internal_has_alter_function_stmt()) {
    clear_has_node();
    ::pg_query::AlterFunctionStmt* temp = node_.alter_function_stmt_;
    node_.alter_function_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_function_stmt(::pg_query::AlterFunctionStmt* alter_function_stmt) {
  clear_node();
  if (alter_function_stmt) {
    set_has_alter_function_stmt();
    node_.alter_function_stmt_ = alter_function_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_function_stmt)
}
inline ::pg_query::AlterFunctionStmt* Node::_internal_mutable_alter_function_stmt() {
  if (!_internal_has_alter_function_stmt()) {
    clear_node();
    set_has_alter_function_stmt();
    node_.alter_function_stmt_ = CreateMaybeMessage< ::pg_query::AlterFunctionStmt >(GetArena());
  }
  return node_.alter_function_stmt_;
}
inline ::pg_query::AlterFunctionStmt* Node::mutable_alter_function_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_function_stmt)
  return _internal_mutable_alter_function_stmt();
}

// .pg_query.DoStmt do_stmt = 77 [json_name = "DoStmt"];
inline bool Node::_internal_has_do_stmt() const {
  return node_case() == kDoStmt;
}
inline bool Node::has_do_stmt() const {
  return _internal_has_do_stmt();
}
inline void Node::set_has_do_stmt() {
  _oneof_case_[0] = kDoStmt;
}
inline void Node::clear_do_stmt() {
  if (_internal_has_do_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.do_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DoStmt* Node::release_do_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.do_stmt)
  if (_internal_has_do_stmt()) {
    clear_has_node();
      ::pg_query::DoStmt* temp = node_.do_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.do_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DoStmt& Node::_internal_do_stmt() const {
  return _internal_has_do_stmt()
      ? *node_.do_stmt_
      : reinterpret_cast< ::pg_query::DoStmt&>(::pg_query::_DoStmt_default_instance_);
}
inline const ::pg_query::DoStmt& Node::do_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.do_stmt)
  return _internal_do_stmt();
}
inline ::pg_query::DoStmt* Node::unsafe_arena_release_do_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.do_stmt)
  if (_internal_has_do_stmt()) {
    clear_has_node();
    ::pg_query::DoStmt* temp = node_.do_stmt_;
    node_.do_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_do_stmt(::pg_query::DoStmt* do_stmt) {
  clear_node();
  if (do_stmt) {
    set_has_do_stmt();
    node_.do_stmt_ = do_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.do_stmt)
}
inline ::pg_query::DoStmt* Node::_internal_mutable_do_stmt() {
  if (!_internal_has_do_stmt()) {
    clear_node();
    set_has_do_stmt();
    node_.do_stmt_ = CreateMaybeMessage< ::pg_query::DoStmt >(GetArena());
  }
  return node_.do_stmt_;
}
inline ::pg_query::DoStmt* Node::mutable_do_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.do_stmt)
  return _internal_mutable_do_stmt();
}

// .pg_query.RenameStmt rename_stmt = 78 [json_name = "RenameStmt"];
inline bool Node::_internal_has_rename_stmt() const {
  return node_case() == kRenameStmt;
}
inline bool Node::has_rename_stmt() const {
  return _internal_has_rename_stmt();
}
inline void Node::set_has_rename_stmt() {
  _oneof_case_[0] = kRenameStmt;
}
inline void Node::clear_rename_stmt() {
  if (_internal_has_rename_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.rename_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RenameStmt* Node::release_rename_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.rename_stmt)
  if (_internal_has_rename_stmt()) {
    clear_has_node();
      ::pg_query::RenameStmt* temp = node_.rename_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.rename_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RenameStmt& Node::_internal_rename_stmt() const {
  return _internal_has_rename_stmt()
      ? *node_.rename_stmt_
      : reinterpret_cast< ::pg_query::RenameStmt&>(::pg_query::_RenameStmt_default_instance_);
}
inline const ::pg_query::RenameStmt& Node::rename_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.rename_stmt)
  return _internal_rename_stmt();
}
inline ::pg_query::RenameStmt* Node::unsafe_arena_release_rename_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.rename_stmt)
  if (_internal_has_rename_stmt()) {
    clear_has_node();
    ::pg_query::RenameStmt* temp = node_.rename_stmt_;
    node_.rename_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_rename_stmt(::pg_query::RenameStmt* rename_stmt) {
  clear_node();
  if (rename_stmt) {
    set_has_rename_stmt();
    node_.rename_stmt_ = rename_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.rename_stmt)
}
inline ::pg_query::RenameStmt* Node::_internal_mutable_rename_stmt() {
  if (!_internal_has_rename_stmt()) {
    clear_node();
    set_has_rename_stmt();
    node_.rename_stmt_ = CreateMaybeMessage< ::pg_query::RenameStmt >(GetArena());
  }
  return node_.rename_stmt_;
}
inline ::pg_query::RenameStmt* Node::mutable_rename_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.rename_stmt)
  return _internal_mutable_rename_stmt();
}

// .pg_query.RuleStmt rule_stmt = 79 [json_name = "RuleStmt"];
inline bool Node::_internal_has_rule_stmt() const {
  return node_case() == kRuleStmt;
}
inline bool Node::has_rule_stmt() const {
  return _internal_has_rule_stmt();
}
inline void Node::set_has_rule_stmt() {
  _oneof_case_[0] = kRuleStmt;
}
inline void Node::clear_rule_stmt() {
  if (_internal_has_rule_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.rule_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RuleStmt* Node::release_rule_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.rule_stmt)
  if (_internal_has_rule_stmt()) {
    clear_has_node();
      ::pg_query::RuleStmt* temp = node_.rule_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.rule_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RuleStmt& Node::_internal_rule_stmt() const {
  return _internal_has_rule_stmt()
      ? *node_.rule_stmt_
      : reinterpret_cast< ::pg_query::RuleStmt&>(::pg_query::_RuleStmt_default_instance_);
}
inline const ::pg_query::RuleStmt& Node::rule_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.rule_stmt)
  return _internal_rule_stmt();
}
inline ::pg_query::RuleStmt* Node::unsafe_arena_release_rule_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.rule_stmt)
  if (_internal_has_rule_stmt()) {
    clear_has_node();
    ::pg_query::RuleStmt* temp = node_.rule_stmt_;
    node_.rule_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_rule_stmt(::pg_query::RuleStmt* rule_stmt) {
  clear_node();
  if (rule_stmt) {
    set_has_rule_stmt();
    node_.rule_stmt_ = rule_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.rule_stmt)
}
inline ::pg_query::RuleStmt* Node::_internal_mutable_rule_stmt() {
  if (!_internal_has_rule_stmt()) {
    clear_node();
    set_has_rule_stmt();
    node_.rule_stmt_ = CreateMaybeMessage< ::pg_query::RuleStmt >(GetArena());
  }
  return node_.rule_stmt_;
}
inline ::pg_query::RuleStmt* Node::mutable_rule_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.rule_stmt)
  return _internal_mutable_rule_stmt();
}

// .pg_query.NotifyStmt notify_stmt = 80 [json_name = "NotifyStmt"];
inline bool Node::_internal_has_notify_stmt() const {
  return node_case() == kNotifyStmt;
}
inline bool Node::has_notify_stmt() const {
  return _internal_has_notify_stmt();
}
inline void Node::set_has_notify_stmt() {
  _oneof_case_[0] = kNotifyStmt;
}
inline void Node::clear_notify_stmt() {
  if (_internal_has_notify_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.notify_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::NotifyStmt* Node::release_notify_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.notify_stmt)
  if (_internal_has_notify_stmt()) {
    clear_has_node();
      ::pg_query::NotifyStmt* temp = node_.notify_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.notify_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::NotifyStmt& Node::_internal_notify_stmt() const {
  return _internal_has_notify_stmt()
      ? *node_.notify_stmt_
      : reinterpret_cast< ::pg_query::NotifyStmt&>(::pg_query::_NotifyStmt_default_instance_);
}
inline const ::pg_query::NotifyStmt& Node::notify_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.notify_stmt)
  return _internal_notify_stmt();
}
inline ::pg_query::NotifyStmt* Node::unsafe_arena_release_notify_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.notify_stmt)
  if (_internal_has_notify_stmt()) {
    clear_has_node();
    ::pg_query::NotifyStmt* temp = node_.notify_stmt_;
    node_.notify_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_notify_stmt(::pg_query::NotifyStmt* notify_stmt) {
  clear_node();
  if (notify_stmt) {
    set_has_notify_stmt();
    node_.notify_stmt_ = notify_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.notify_stmt)
}
inline ::pg_query::NotifyStmt* Node::_internal_mutable_notify_stmt() {
  if (!_internal_has_notify_stmt()) {
    clear_node();
    set_has_notify_stmt();
    node_.notify_stmt_ = CreateMaybeMessage< ::pg_query::NotifyStmt >(GetArena());
  }
  return node_.notify_stmt_;
}
inline ::pg_query::NotifyStmt* Node::mutable_notify_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.notify_stmt)
  return _internal_mutable_notify_stmt();
}

// .pg_query.ListenStmt listen_stmt = 81 [json_name = "ListenStmt"];
inline bool Node::_internal_has_listen_stmt() const {
  return node_case() == kListenStmt;
}
inline bool Node::has_listen_stmt() const {
  return _internal_has_listen_stmt();
}
inline void Node::set_has_listen_stmt() {
  _oneof_case_[0] = kListenStmt;
}
inline void Node::clear_listen_stmt() {
  if (_internal_has_listen_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.listen_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ListenStmt* Node::release_listen_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.listen_stmt)
  if (_internal_has_listen_stmt()) {
    clear_has_node();
      ::pg_query::ListenStmt* temp = node_.listen_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.listen_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ListenStmt& Node::_internal_listen_stmt() const {
  return _internal_has_listen_stmt()
      ? *node_.listen_stmt_
      : reinterpret_cast< ::pg_query::ListenStmt&>(::pg_query::_ListenStmt_default_instance_);
}
inline const ::pg_query::ListenStmt& Node::listen_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.listen_stmt)
  return _internal_listen_stmt();
}
inline ::pg_query::ListenStmt* Node::unsafe_arena_release_listen_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.listen_stmt)
  if (_internal_has_listen_stmt()) {
    clear_has_node();
    ::pg_query::ListenStmt* temp = node_.listen_stmt_;
    node_.listen_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_listen_stmt(::pg_query::ListenStmt* listen_stmt) {
  clear_node();
  if (listen_stmt) {
    set_has_listen_stmt();
    node_.listen_stmt_ = listen_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.listen_stmt)
}
inline ::pg_query::ListenStmt* Node::_internal_mutable_listen_stmt() {
  if (!_internal_has_listen_stmt()) {
    clear_node();
    set_has_listen_stmt();
    node_.listen_stmt_ = CreateMaybeMessage< ::pg_query::ListenStmt >(GetArena());
  }
  return node_.listen_stmt_;
}
inline ::pg_query::ListenStmt* Node::mutable_listen_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.listen_stmt)
  return _internal_mutable_listen_stmt();
}

// .pg_query.UnlistenStmt unlisten_stmt = 82 [json_name = "UnlistenStmt"];
inline bool Node::_internal_has_unlisten_stmt() const {
  return node_case() == kUnlistenStmt;
}
inline bool Node::has_unlisten_stmt() const {
  return _internal_has_unlisten_stmt();
}
inline void Node::set_has_unlisten_stmt() {
  _oneof_case_[0] = kUnlistenStmt;
}
inline void Node::clear_unlisten_stmt() {
  if (_internal_has_unlisten_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.unlisten_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::UnlistenStmt* Node::release_unlisten_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.unlisten_stmt)
  if (_internal_has_unlisten_stmt()) {
    clear_has_node();
      ::pg_query::UnlistenStmt* temp = node_.unlisten_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.unlisten_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::UnlistenStmt& Node::_internal_unlisten_stmt() const {
  return _internal_has_unlisten_stmt()
      ? *node_.unlisten_stmt_
      : reinterpret_cast< ::pg_query::UnlistenStmt&>(::pg_query::_UnlistenStmt_default_instance_);
}
inline const ::pg_query::UnlistenStmt& Node::unlisten_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.unlisten_stmt)
  return _internal_unlisten_stmt();
}
inline ::pg_query::UnlistenStmt* Node::unsafe_arena_release_unlisten_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.unlisten_stmt)
  if (_internal_has_unlisten_stmt()) {
    clear_has_node();
    ::pg_query::UnlistenStmt* temp = node_.unlisten_stmt_;
    node_.unlisten_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_unlisten_stmt(::pg_query::UnlistenStmt* unlisten_stmt) {
  clear_node();
  if (unlisten_stmt) {
    set_has_unlisten_stmt();
    node_.unlisten_stmt_ = unlisten_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.unlisten_stmt)
}
inline ::pg_query::UnlistenStmt* Node::_internal_mutable_unlisten_stmt() {
  if (!_internal_has_unlisten_stmt()) {
    clear_node();
    set_has_unlisten_stmt();
    node_.unlisten_stmt_ = CreateMaybeMessage< ::pg_query::UnlistenStmt >(GetArena());
  }
  return node_.unlisten_stmt_;
}
inline ::pg_query::UnlistenStmt* Node::mutable_unlisten_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.unlisten_stmt)
  return _internal_mutable_unlisten_stmt();
}

// .pg_query.TransactionStmt transaction_stmt = 83 [json_name = "TransactionStmt"];
inline bool Node::_internal_has_transaction_stmt() const {
  return node_case() == kTransactionStmt;
}
inline bool Node::has_transaction_stmt() const {
  return _internal_has_transaction_stmt();
}
inline void Node::set_has_transaction_stmt() {
  _oneof_case_[0] = kTransactionStmt;
}
inline void Node::clear_transaction_stmt() {
  if (_internal_has_transaction_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.transaction_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::TransactionStmt* Node::release_transaction_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.transaction_stmt)
  if (_internal_has_transaction_stmt()) {
    clear_has_node();
      ::pg_query::TransactionStmt* temp = node_.transaction_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.transaction_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TransactionStmt& Node::_internal_transaction_stmt() const {
  return _internal_has_transaction_stmt()
      ? *node_.transaction_stmt_
      : reinterpret_cast< ::pg_query::TransactionStmt&>(::pg_query::_TransactionStmt_default_instance_);
}
inline const ::pg_query::TransactionStmt& Node::transaction_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.transaction_stmt)
  return _internal_transaction_stmt();
}
inline ::pg_query::TransactionStmt* Node::unsafe_arena_release_transaction_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.transaction_stmt)
  if (_internal_has_transaction_stmt()) {
    clear_has_node();
    ::pg_query::TransactionStmt* temp = node_.transaction_stmt_;
    node_.transaction_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_transaction_stmt(::pg_query::TransactionStmt* transaction_stmt) {
  clear_node();
  if (transaction_stmt) {
    set_has_transaction_stmt();
    node_.transaction_stmt_ = transaction_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.transaction_stmt)
}
inline ::pg_query::TransactionStmt* Node::_internal_mutable_transaction_stmt() {
  if (!_internal_has_transaction_stmt()) {
    clear_node();
    set_has_transaction_stmt();
    node_.transaction_stmt_ = CreateMaybeMessage< ::pg_query::TransactionStmt >(GetArena());
  }
  return node_.transaction_stmt_;
}
inline ::pg_query::TransactionStmt* Node::mutable_transaction_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.transaction_stmt)
  return _internal_mutable_transaction_stmt();
}

// .pg_query.ViewStmt view_stmt = 84 [json_name = "ViewStmt"];
inline bool Node::_internal_has_view_stmt() const {
  return node_case() == kViewStmt;
}
inline bool Node::has_view_stmt() const {
  return _internal_has_view_stmt();
}
inline void Node::set_has_view_stmt() {
  _oneof_case_[0] = kViewStmt;
}
inline void Node::clear_view_stmt() {
  if (_internal_has_view_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.view_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ViewStmt* Node::release_view_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.view_stmt)
  if (_internal_has_view_stmt()) {
    clear_has_node();
      ::pg_query::ViewStmt* temp = node_.view_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.view_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ViewStmt& Node::_internal_view_stmt() const {
  return _internal_has_view_stmt()
      ? *node_.view_stmt_
      : reinterpret_cast< ::pg_query::ViewStmt&>(::pg_query::_ViewStmt_default_instance_);
}
inline const ::pg_query::ViewStmt& Node::view_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.view_stmt)
  return _internal_view_stmt();
}
inline ::pg_query::ViewStmt* Node::unsafe_arena_release_view_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.view_stmt)
  if (_internal_has_view_stmt()) {
    clear_has_node();
    ::pg_query::ViewStmt* temp = node_.view_stmt_;
    node_.view_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_view_stmt(::pg_query::ViewStmt* view_stmt) {
  clear_node();
  if (view_stmt) {
    set_has_view_stmt();
    node_.view_stmt_ = view_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.view_stmt)
}
inline ::pg_query::ViewStmt* Node::_internal_mutable_view_stmt() {
  if (!_internal_has_view_stmt()) {
    clear_node();
    set_has_view_stmt();
    node_.view_stmt_ = CreateMaybeMessage< ::pg_query::ViewStmt >(GetArena());
  }
  return node_.view_stmt_;
}
inline ::pg_query::ViewStmt* Node::mutable_view_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.view_stmt)
  return _internal_mutable_view_stmt();
}

// .pg_query.LoadStmt load_stmt = 85 [json_name = "LoadStmt"];
inline bool Node::_internal_has_load_stmt() const {
  return node_case() == kLoadStmt;
}
inline bool Node::has_load_stmt() const {
  return _internal_has_load_stmt();
}
inline void Node::set_has_load_stmt() {
  _oneof_case_[0] = kLoadStmt;
}
inline void Node::clear_load_stmt() {
  if (_internal_has_load_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.load_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::LoadStmt* Node::release_load_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.load_stmt)
  if (_internal_has_load_stmt()) {
    clear_has_node();
      ::pg_query::LoadStmt* temp = node_.load_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.load_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::LoadStmt& Node::_internal_load_stmt() const {
  return _internal_has_load_stmt()
      ? *node_.load_stmt_
      : reinterpret_cast< ::pg_query::LoadStmt&>(::pg_query::_LoadStmt_default_instance_);
}
inline const ::pg_query::LoadStmt& Node::load_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.load_stmt)
  return _internal_load_stmt();
}
inline ::pg_query::LoadStmt* Node::unsafe_arena_release_load_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.load_stmt)
  if (_internal_has_load_stmt()) {
    clear_has_node();
    ::pg_query::LoadStmt* temp = node_.load_stmt_;
    node_.load_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_load_stmt(::pg_query::LoadStmt* load_stmt) {
  clear_node();
  if (load_stmt) {
    set_has_load_stmt();
    node_.load_stmt_ = load_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.load_stmt)
}
inline ::pg_query::LoadStmt* Node::_internal_mutable_load_stmt() {
  if (!_internal_has_load_stmt()) {
    clear_node();
    set_has_load_stmt();
    node_.load_stmt_ = CreateMaybeMessage< ::pg_query::LoadStmt >(GetArena());
  }
  return node_.load_stmt_;
}
inline ::pg_query::LoadStmt* Node::mutable_load_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.load_stmt)
  return _internal_mutable_load_stmt();
}

// .pg_query.CreateDomainStmt create_domain_stmt = 86 [json_name = "CreateDomainStmt"];
inline bool Node::_internal_has_create_domain_stmt() const {
  return node_case() == kCreateDomainStmt;
}
inline bool Node::has_create_domain_stmt() const {
  return _internal_has_create_domain_stmt();
}
inline void Node::set_has_create_domain_stmt() {
  _oneof_case_[0] = kCreateDomainStmt;
}
inline void Node::clear_create_domain_stmt() {
  if (_internal_has_create_domain_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_domain_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateDomainStmt* Node::release_create_domain_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_domain_stmt)
  if (_internal_has_create_domain_stmt()) {
    clear_has_node();
      ::pg_query::CreateDomainStmt* temp = node_.create_domain_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_domain_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateDomainStmt& Node::_internal_create_domain_stmt() const {
  return _internal_has_create_domain_stmt()
      ? *node_.create_domain_stmt_
      : reinterpret_cast< ::pg_query::CreateDomainStmt&>(::pg_query::_CreateDomainStmt_default_instance_);
}
inline const ::pg_query::CreateDomainStmt& Node::create_domain_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_domain_stmt)
  return _internal_create_domain_stmt();
}
inline ::pg_query::CreateDomainStmt* Node::unsafe_arena_release_create_domain_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_domain_stmt)
  if (_internal_has_create_domain_stmt()) {
    clear_has_node();
    ::pg_query::CreateDomainStmt* temp = node_.create_domain_stmt_;
    node_.create_domain_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_domain_stmt(::pg_query::CreateDomainStmt* create_domain_stmt) {
  clear_node();
  if (create_domain_stmt) {
    set_has_create_domain_stmt();
    node_.create_domain_stmt_ = create_domain_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_domain_stmt)
}
inline ::pg_query::CreateDomainStmt* Node::_internal_mutable_create_domain_stmt() {
  if (!_internal_has_create_domain_stmt()) {
    clear_node();
    set_has_create_domain_stmt();
    node_.create_domain_stmt_ = CreateMaybeMessage< ::pg_query::CreateDomainStmt >(GetArena());
  }
  return node_.create_domain_stmt_;
}
inline ::pg_query::CreateDomainStmt* Node::mutable_create_domain_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_domain_stmt)
  return _internal_mutable_create_domain_stmt();
}

// .pg_query.CreatedbStmt createdb_stmt = 87 [json_name = "CreatedbStmt"];
inline bool Node::_internal_has_createdb_stmt() const {
  return node_case() == kCreatedbStmt;
}
inline bool Node::has_createdb_stmt() const {
  return _internal_has_createdb_stmt();
}
inline void Node::set_has_createdb_stmt() {
  _oneof_case_[0] = kCreatedbStmt;
}
inline void Node::clear_createdb_stmt() {
  if (_internal_has_createdb_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.createdb_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreatedbStmt* Node::release_createdb_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.createdb_stmt)
  if (_internal_has_createdb_stmt()) {
    clear_has_node();
      ::pg_query::CreatedbStmt* temp = node_.createdb_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.createdb_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreatedbStmt& Node::_internal_createdb_stmt() const {
  return _internal_has_createdb_stmt()
      ? *node_.createdb_stmt_
      : reinterpret_cast< ::pg_query::CreatedbStmt&>(::pg_query::_CreatedbStmt_default_instance_);
}
inline const ::pg_query::CreatedbStmt& Node::createdb_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.createdb_stmt)
  return _internal_createdb_stmt();
}
inline ::pg_query::CreatedbStmt* Node::unsafe_arena_release_createdb_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.createdb_stmt)
  if (_internal_has_createdb_stmt()) {
    clear_has_node();
    ::pg_query::CreatedbStmt* temp = node_.createdb_stmt_;
    node_.createdb_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_createdb_stmt(::pg_query::CreatedbStmt* createdb_stmt) {
  clear_node();
  if (createdb_stmt) {
    set_has_createdb_stmt();
    node_.createdb_stmt_ = createdb_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.createdb_stmt)
}
inline ::pg_query::CreatedbStmt* Node::_internal_mutable_createdb_stmt() {
  if (!_internal_has_createdb_stmt()) {
    clear_node();
    set_has_createdb_stmt();
    node_.createdb_stmt_ = CreateMaybeMessage< ::pg_query::CreatedbStmt >(GetArena());
  }
  return node_.createdb_stmt_;
}
inline ::pg_query::CreatedbStmt* Node::mutable_createdb_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.createdb_stmt)
  return _internal_mutable_createdb_stmt();
}

// .pg_query.DropdbStmt dropdb_stmt = 88 [json_name = "DropdbStmt"];
inline bool Node::_internal_has_dropdb_stmt() const {
  return node_case() == kDropdbStmt;
}
inline bool Node::has_dropdb_stmt() const {
  return _internal_has_dropdb_stmt();
}
inline void Node::set_has_dropdb_stmt() {
  _oneof_case_[0] = kDropdbStmt;
}
inline void Node::clear_dropdb_stmt() {
  if (_internal_has_dropdb_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.dropdb_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DropdbStmt* Node::release_dropdb_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.dropdb_stmt)
  if (_internal_has_dropdb_stmt()) {
    clear_has_node();
      ::pg_query::DropdbStmt* temp = node_.dropdb_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.dropdb_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropdbStmt& Node::_internal_dropdb_stmt() const {
  return _internal_has_dropdb_stmt()
      ? *node_.dropdb_stmt_
      : reinterpret_cast< ::pg_query::DropdbStmt&>(::pg_query::_DropdbStmt_default_instance_);
}
inline const ::pg_query::DropdbStmt& Node::dropdb_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.dropdb_stmt)
  return _internal_dropdb_stmt();
}
inline ::pg_query::DropdbStmt* Node::unsafe_arena_release_dropdb_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.dropdb_stmt)
  if (_internal_has_dropdb_stmt()) {
    clear_has_node();
    ::pg_query::DropdbStmt* temp = node_.dropdb_stmt_;
    node_.dropdb_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_dropdb_stmt(::pg_query::DropdbStmt* dropdb_stmt) {
  clear_node();
  if (dropdb_stmt) {
    set_has_dropdb_stmt();
    node_.dropdb_stmt_ = dropdb_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.dropdb_stmt)
}
inline ::pg_query::DropdbStmt* Node::_internal_mutable_dropdb_stmt() {
  if (!_internal_has_dropdb_stmt()) {
    clear_node();
    set_has_dropdb_stmt();
    node_.dropdb_stmt_ = CreateMaybeMessage< ::pg_query::DropdbStmt >(GetArena());
  }
  return node_.dropdb_stmt_;
}
inline ::pg_query::DropdbStmt* Node::mutable_dropdb_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.dropdb_stmt)
  return _internal_mutable_dropdb_stmt();
}

// .pg_query.VacuumStmt vacuum_stmt = 89 [json_name = "VacuumStmt"];
inline bool Node::_internal_has_vacuum_stmt() const {
  return node_case() == kVacuumStmt;
}
inline bool Node::has_vacuum_stmt() const {
  return _internal_has_vacuum_stmt();
}
inline void Node::set_has_vacuum_stmt() {
  _oneof_case_[0] = kVacuumStmt;
}
inline void Node::clear_vacuum_stmt() {
  if (_internal_has_vacuum_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.vacuum_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::VacuumStmt* Node::release_vacuum_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.vacuum_stmt)
  if (_internal_has_vacuum_stmt()) {
    clear_has_node();
      ::pg_query::VacuumStmt* temp = node_.vacuum_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.vacuum_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::VacuumStmt& Node::_internal_vacuum_stmt() const {
  return _internal_has_vacuum_stmt()
      ? *node_.vacuum_stmt_
      : reinterpret_cast< ::pg_query::VacuumStmt&>(::pg_query::_VacuumStmt_default_instance_);
}
inline const ::pg_query::VacuumStmt& Node::vacuum_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.vacuum_stmt)
  return _internal_vacuum_stmt();
}
inline ::pg_query::VacuumStmt* Node::unsafe_arena_release_vacuum_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.vacuum_stmt)
  if (_internal_has_vacuum_stmt()) {
    clear_has_node();
    ::pg_query::VacuumStmt* temp = node_.vacuum_stmt_;
    node_.vacuum_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_vacuum_stmt(::pg_query::VacuumStmt* vacuum_stmt) {
  clear_node();
  if (vacuum_stmt) {
    set_has_vacuum_stmt();
    node_.vacuum_stmt_ = vacuum_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.vacuum_stmt)
}
inline ::pg_query::VacuumStmt* Node::_internal_mutable_vacuum_stmt() {
  if (!_internal_has_vacuum_stmt()) {
    clear_node();
    set_has_vacuum_stmt();
    node_.vacuum_stmt_ = CreateMaybeMessage< ::pg_query::VacuumStmt >(GetArena());
  }
  return node_.vacuum_stmt_;
}
inline ::pg_query::VacuumStmt* Node::mutable_vacuum_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.vacuum_stmt)
  return _internal_mutable_vacuum_stmt();
}

// .pg_query.ExplainStmt explain_stmt = 90 [json_name = "ExplainStmt"];
inline bool Node::_internal_has_explain_stmt() const {
  return node_case() == kExplainStmt;
}
inline bool Node::has_explain_stmt() const {
  return _internal_has_explain_stmt();
}
inline void Node::set_has_explain_stmt() {
  _oneof_case_[0] = kExplainStmt;
}
inline void Node::clear_explain_stmt() {
  if (_internal_has_explain_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.explain_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ExplainStmt* Node::release_explain_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.explain_stmt)
  if (_internal_has_explain_stmt()) {
    clear_has_node();
      ::pg_query::ExplainStmt* temp = node_.explain_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.explain_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ExplainStmt& Node::_internal_explain_stmt() const {
  return _internal_has_explain_stmt()
      ? *node_.explain_stmt_
      : reinterpret_cast< ::pg_query::ExplainStmt&>(::pg_query::_ExplainStmt_default_instance_);
}
inline const ::pg_query::ExplainStmt& Node::explain_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.explain_stmt)
  return _internal_explain_stmt();
}
inline ::pg_query::ExplainStmt* Node::unsafe_arena_release_explain_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.explain_stmt)
  if (_internal_has_explain_stmt()) {
    clear_has_node();
    ::pg_query::ExplainStmt* temp = node_.explain_stmt_;
    node_.explain_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_explain_stmt(::pg_query::ExplainStmt* explain_stmt) {
  clear_node();
  if (explain_stmt) {
    set_has_explain_stmt();
    node_.explain_stmt_ = explain_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.explain_stmt)
}
inline ::pg_query::ExplainStmt* Node::_internal_mutable_explain_stmt() {
  if (!_internal_has_explain_stmt()) {
    clear_node();
    set_has_explain_stmt();
    node_.explain_stmt_ = CreateMaybeMessage< ::pg_query::ExplainStmt >(GetArena());
  }
  return node_.explain_stmt_;
}
inline ::pg_query::ExplainStmt* Node::mutable_explain_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.explain_stmt)
  return _internal_mutable_explain_stmt();
}

// .pg_query.CreateTableAsStmt create_table_as_stmt = 91 [json_name = "CreateTableAsStmt"];
inline bool Node::_internal_has_create_table_as_stmt() const {
  return node_case() == kCreateTableAsStmt;
}
inline bool Node::has_create_table_as_stmt() const {
  return _internal_has_create_table_as_stmt();
}
inline void Node::set_has_create_table_as_stmt() {
  _oneof_case_[0] = kCreateTableAsStmt;
}
inline void Node::clear_create_table_as_stmt() {
  if (_internal_has_create_table_as_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_table_as_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateTableAsStmt* Node::release_create_table_as_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_table_as_stmt)
  if (_internal_has_create_table_as_stmt()) {
    clear_has_node();
      ::pg_query::CreateTableAsStmt* temp = node_.create_table_as_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_table_as_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateTableAsStmt& Node::_internal_create_table_as_stmt() const {
  return _internal_has_create_table_as_stmt()
      ? *node_.create_table_as_stmt_
      : reinterpret_cast< ::pg_query::CreateTableAsStmt&>(::pg_query::_CreateTableAsStmt_default_instance_);
}
inline const ::pg_query::CreateTableAsStmt& Node::create_table_as_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_table_as_stmt)
  return _internal_create_table_as_stmt();
}
inline ::pg_query::CreateTableAsStmt* Node::unsafe_arena_release_create_table_as_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_table_as_stmt)
  if (_internal_has_create_table_as_stmt()) {
    clear_has_node();
    ::pg_query::CreateTableAsStmt* temp = node_.create_table_as_stmt_;
    node_.create_table_as_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_table_as_stmt(::pg_query::CreateTableAsStmt* create_table_as_stmt) {
  clear_node();
  if (create_table_as_stmt) {
    set_has_create_table_as_stmt();
    node_.create_table_as_stmt_ = create_table_as_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_table_as_stmt)
}
inline ::pg_query::CreateTableAsStmt* Node::_internal_mutable_create_table_as_stmt() {
  if (!_internal_has_create_table_as_stmt()) {
    clear_node();
    set_has_create_table_as_stmt();
    node_.create_table_as_stmt_ = CreateMaybeMessage< ::pg_query::CreateTableAsStmt >(GetArena());
  }
  return node_.create_table_as_stmt_;
}
inline ::pg_query::CreateTableAsStmt* Node::mutable_create_table_as_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_table_as_stmt)
  return _internal_mutable_create_table_as_stmt();
}

// .pg_query.CreateSeqStmt create_seq_stmt = 92 [json_name = "CreateSeqStmt"];
inline bool Node::_internal_has_create_seq_stmt() const {
  return node_case() == kCreateSeqStmt;
}
inline bool Node::has_create_seq_stmt() const {
  return _internal_has_create_seq_stmt();
}
inline void Node::set_has_create_seq_stmt() {
  _oneof_case_[0] = kCreateSeqStmt;
}
inline void Node::clear_create_seq_stmt() {
  if (_internal_has_create_seq_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_seq_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateSeqStmt* Node::release_create_seq_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_seq_stmt)
  if (_internal_has_create_seq_stmt()) {
    clear_has_node();
      ::pg_query::CreateSeqStmt* temp = node_.create_seq_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_seq_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateSeqStmt& Node::_internal_create_seq_stmt() const {
  return _internal_has_create_seq_stmt()
      ? *node_.create_seq_stmt_
      : reinterpret_cast< ::pg_query::CreateSeqStmt&>(::pg_query::_CreateSeqStmt_default_instance_);
}
inline const ::pg_query::CreateSeqStmt& Node::create_seq_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_seq_stmt)
  return _internal_create_seq_stmt();
}
inline ::pg_query::CreateSeqStmt* Node::unsafe_arena_release_create_seq_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_seq_stmt)
  if (_internal_has_create_seq_stmt()) {
    clear_has_node();
    ::pg_query::CreateSeqStmt* temp = node_.create_seq_stmt_;
    node_.create_seq_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_seq_stmt(::pg_query::CreateSeqStmt* create_seq_stmt) {
  clear_node();
  if (create_seq_stmt) {
    set_has_create_seq_stmt();
    node_.create_seq_stmt_ = create_seq_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_seq_stmt)
}
inline ::pg_query::CreateSeqStmt* Node::_internal_mutable_create_seq_stmt() {
  if (!_internal_has_create_seq_stmt()) {
    clear_node();
    set_has_create_seq_stmt();
    node_.create_seq_stmt_ = CreateMaybeMessage< ::pg_query::CreateSeqStmt >(GetArena());
  }
  return node_.create_seq_stmt_;
}
inline ::pg_query::CreateSeqStmt* Node::mutable_create_seq_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_seq_stmt)
  return _internal_mutable_create_seq_stmt();
}

// .pg_query.AlterSeqStmt alter_seq_stmt = 93 [json_name = "AlterSeqStmt"];
inline bool Node::_internal_has_alter_seq_stmt() const {
  return node_case() == kAlterSeqStmt;
}
inline bool Node::has_alter_seq_stmt() const {
  return _internal_has_alter_seq_stmt();
}
inline void Node::set_has_alter_seq_stmt() {
  _oneof_case_[0] = kAlterSeqStmt;
}
inline void Node::clear_alter_seq_stmt() {
  if (_internal_has_alter_seq_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_seq_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterSeqStmt* Node::release_alter_seq_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_seq_stmt)
  if (_internal_has_alter_seq_stmt()) {
    clear_has_node();
      ::pg_query::AlterSeqStmt* temp = node_.alter_seq_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_seq_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterSeqStmt& Node::_internal_alter_seq_stmt() const {
  return _internal_has_alter_seq_stmt()
      ? *node_.alter_seq_stmt_
      : reinterpret_cast< ::pg_query::AlterSeqStmt&>(::pg_query::_AlterSeqStmt_default_instance_);
}
inline const ::pg_query::AlterSeqStmt& Node::alter_seq_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_seq_stmt)
  return _internal_alter_seq_stmt();
}
inline ::pg_query::AlterSeqStmt* Node::unsafe_arena_release_alter_seq_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_seq_stmt)
  if (_internal_has_alter_seq_stmt()) {
    clear_has_node();
    ::pg_query::AlterSeqStmt* temp = node_.alter_seq_stmt_;
    node_.alter_seq_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_seq_stmt(::pg_query::AlterSeqStmt* alter_seq_stmt) {
  clear_node();
  if (alter_seq_stmt) {
    set_has_alter_seq_stmt();
    node_.alter_seq_stmt_ = alter_seq_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_seq_stmt)
}
inline ::pg_query::AlterSeqStmt* Node::_internal_mutable_alter_seq_stmt() {
  if (!_internal_has_alter_seq_stmt()) {
    clear_node();
    set_has_alter_seq_stmt();
    node_.alter_seq_stmt_ = CreateMaybeMessage< ::pg_query::AlterSeqStmt >(GetArena());
  }
  return node_.alter_seq_stmt_;
}
inline ::pg_query::AlterSeqStmt* Node::mutable_alter_seq_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_seq_stmt)
  return _internal_mutable_alter_seq_stmt();
}

// .pg_query.VariableSetStmt variable_set_stmt = 94 [json_name = "VariableSetStmt"];
inline bool Node::_internal_has_variable_set_stmt() const {
  return node_case() == kVariableSetStmt;
}
inline bool Node::has_variable_set_stmt() const {
  return _internal_has_variable_set_stmt();
}
inline void Node::set_has_variable_set_stmt() {
  _oneof_case_[0] = kVariableSetStmt;
}
inline void Node::clear_variable_set_stmt() {
  if (_internal_has_variable_set_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.variable_set_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::VariableSetStmt* Node::release_variable_set_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.variable_set_stmt)
  if (_internal_has_variable_set_stmt()) {
    clear_has_node();
      ::pg_query::VariableSetStmt* temp = node_.variable_set_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.variable_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::VariableSetStmt& Node::_internal_variable_set_stmt() const {
  return _internal_has_variable_set_stmt()
      ? *node_.variable_set_stmt_
      : reinterpret_cast< ::pg_query::VariableSetStmt&>(::pg_query::_VariableSetStmt_default_instance_);
}
inline const ::pg_query::VariableSetStmt& Node::variable_set_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.variable_set_stmt)
  return _internal_variable_set_stmt();
}
inline ::pg_query::VariableSetStmt* Node::unsafe_arena_release_variable_set_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.variable_set_stmt)
  if (_internal_has_variable_set_stmt()) {
    clear_has_node();
    ::pg_query::VariableSetStmt* temp = node_.variable_set_stmt_;
    node_.variable_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_variable_set_stmt(::pg_query::VariableSetStmt* variable_set_stmt) {
  clear_node();
  if (variable_set_stmt) {
    set_has_variable_set_stmt();
    node_.variable_set_stmt_ = variable_set_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.variable_set_stmt)
}
inline ::pg_query::VariableSetStmt* Node::_internal_mutable_variable_set_stmt() {
  if (!_internal_has_variable_set_stmt()) {
    clear_node();
    set_has_variable_set_stmt();
    node_.variable_set_stmt_ = CreateMaybeMessage< ::pg_query::VariableSetStmt >(GetArena());
  }
  return node_.variable_set_stmt_;
}
inline ::pg_query::VariableSetStmt* Node::mutable_variable_set_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.variable_set_stmt)
  return _internal_mutable_variable_set_stmt();
}

// .pg_query.VariableShowStmt variable_show_stmt = 95 [json_name = "VariableShowStmt"];
inline bool Node::_internal_has_variable_show_stmt() const {
  return node_case() == kVariableShowStmt;
}
inline bool Node::has_variable_show_stmt() const {
  return _internal_has_variable_show_stmt();
}
inline void Node::set_has_variable_show_stmt() {
  _oneof_case_[0] = kVariableShowStmt;
}
inline void Node::clear_variable_show_stmt() {
  if (_internal_has_variable_show_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.variable_show_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::VariableShowStmt* Node::release_variable_show_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.variable_show_stmt)
  if (_internal_has_variable_show_stmt()) {
    clear_has_node();
      ::pg_query::VariableShowStmt* temp = node_.variable_show_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.variable_show_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::VariableShowStmt& Node::_internal_variable_show_stmt() const {
  return _internal_has_variable_show_stmt()
      ? *node_.variable_show_stmt_
      : reinterpret_cast< ::pg_query::VariableShowStmt&>(::pg_query::_VariableShowStmt_default_instance_);
}
inline const ::pg_query::VariableShowStmt& Node::variable_show_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.variable_show_stmt)
  return _internal_variable_show_stmt();
}
inline ::pg_query::VariableShowStmt* Node::unsafe_arena_release_variable_show_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.variable_show_stmt)
  if (_internal_has_variable_show_stmt()) {
    clear_has_node();
    ::pg_query::VariableShowStmt* temp = node_.variable_show_stmt_;
    node_.variable_show_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_variable_show_stmt(::pg_query::VariableShowStmt* variable_show_stmt) {
  clear_node();
  if (variable_show_stmt) {
    set_has_variable_show_stmt();
    node_.variable_show_stmt_ = variable_show_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.variable_show_stmt)
}
inline ::pg_query::VariableShowStmt* Node::_internal_mutable_variable_show_stmt() {
  if (!_internal_has_variable_show_stmt()) {
    clear_node();
    set_has_variable_show_stmt();
    node_.variable_show_stmt_ = CreateMaybeMessage< ::pg_query::VariableShowStmt >(GetArena());
  }
  return node_.variable_show_stmt_;
}
inline ::pg_query::VariableShowStmt* Node::mutable_variable_show_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.variable_show_stmt)
  return _internal_mutable_variable_show_stmt();
}

// .pg_query.DiscardStmt discard_stmt = 96 [json_name = "DiscardStmt"];
inline bool Node::_internal_has_discard_stmt() const {
  return node_case() == kDiscardStmt;
}
inline bool Node::has_discard_stmt() const {
  return _internal_has_discard_stmt();
}
inline void Node::set_has_discard_stmt() {
  _oneof_case_[0] = kDiscardStmt;
}
inline void Node::clear_discard_stmt() {
  if (_internal_has_discard_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.discard_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DiscardStmt* Node::release_discard_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.discard_stmt)
  if (_internal_has_discard_stmt()) {
    clear_has_node();
      ::pg_query::DiscardStmt* temp = node_.discard_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.discard_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DiscardStmt& Node::_internal_discard_stmt() const {
  return _internal_has_discard_stmt()
      ? *node_.discard_stmt_
      : reinterpret_cast< ::pg_query::DiscardStmt&>(::pg_query::_DiscardStmt_default_instance_);
}
inline const ::pg_query::DiscardStmt& Node::discard_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.discard_stmt)
  return _internal_discard_stmt();
}
inline ::pg_query::DiscardStmt* Node::unsafe_arena_release_discard_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.discard_stmt)
  if (_internal_has_discard_stmt()) {
    clear_has_node();
    ::pg_query::DiscardStmt* temp = node_.discard_stmt_;
    node_.discard_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_discard_stmt(::pg_query::DiscardStmt* discard_stmt) {
  clear_node();
  if (discard_stmt) {
    set_has_discard_stmt();
    node_.discard_stmt_ = discard_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.discard_stmt)
}
inline ::pg_query::DiscardStmt* Node::_internal_mutable_discard_stmt() {
  if (!_internal_has_discard_stmt()) {
    clear_node();
    set_has_discard_stmt();
    node_.discard_stmt_ = CreateMaybeMessage< ::pg_query::DiscardStmt >(GetArena());
  }
  return node_.discard_stmt_;
}
inline ::pg_query::DiscardStmt* Node::mutable_discard_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.discard_stmt)
  return _internal_mutable_discard_stmt();
}

// .pg_query.CreateTrigStmt create_trig_stmt = 97 [json_name = "CreateTrigStmt"];
inline bool Node::_internal_has_create_trig_stmt() const {
  return node_case() == kCreateTrigStmt;
}
inline bool Node::has_create_trig_stmt() const {
  return _internal_has_create_trig_stmt();
}
inline void Node::set_has_create_trig_stmt() {
  _oneof_case_[0] = kCreateTrigStmt;
}
inline void Node::clear_create_trig_stmt() {
  if (_internal_has_create_trig_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_trig_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateTrigStmt* Node::release_create_trig_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_trig_stmt)
  if (_internal_has_create_trig_stmt()) {
    clear_has_node();
      ::pg_query::CreateTrigStmt* temp = node_.create_trig_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_trig_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateTrigStmt& Node::_internal_create_trig_stmt() const {
  return _internal_has_create_trig_stmt()
      ? *node_.create_trig_stmt_
      : reinterpret_cast< ::pg_query::CreateTrigStmt&>(::pg_query::_CreateTrigStmt_default_instance_);
}
inline const ::pg_query::CreateTrigStmt& Node::create_trig_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_trig_stmt)
  return _internal_create_trig_stmt();
}
inline ::pg_query::CreateTrigStmt* Node::unsafe_arena_release_create_trig_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_trig_stmt)
  if (_internal_has_create_trig_stmt()) {
    clear_has_node();
    ::pg_query::CreateTrigStmt* temp = node_.create_trig_stmt_;
    node_.create_trig_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_trig_stmt(::pg_query::CreateTrigStmt* create_trig_stmt) {
  clear_node();
  if (create_trig_stmt) {
    set_has_create_trig_stmt();
    node_.create_trig_stmt_ = create_trig_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_trig_stmt)
}
inline ::pg_query::CreateTrigStmt* Node::_internal_mutable_create_trig_stmt() {
  if (!_internal_has_create_trig_stmt()) {
    clear_node();
    set_has_create_trig_stmt();
    node_.create_trig_stmt_ = CreateMaybeMessage< ::pg_query::CreateTrigStmt >(GetArena());
  }
  return node_.create_trig_stmt_;
}
inline ::pg_query::CreateTrigStmt* Node::mutable_create_trig_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_trig_stmt)
  return _internal_mutable_create_trig_stmt();
}

// .pg_query.CreatePLangStmt create_plang_stmt = 98 [json_name = "CreatePLangStmt"];
inline bool Node::_internal_has_create_plang_stmt() const {
  return node_case() == kCreatePlangStmt;
}
inline bool Node::has_create_plang_stmt() const {
  return _internal_has_create_plang_stmt();
}
inline void Node::set_has_create_plang_stmt() {
  _oneof_case_[0] = kCreatePlangStmt;
}
inline void Node::clear_create_plang_stmt() {
  if (_internal_has_create_plang_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_plang_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreatePLangStmt* Node::release_create_plang_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_plang_stmt)
  if (_internal_has_create_plang_stmt()) {
    clear_has_node();
      ::pg_query::CreatePLangStmt* temp = node_.create_plang_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_plang_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreatePLangStmt& Node::_internal_create_plang_stmt() const {
  return _internal_has_create_plang_stmt()
      ? *node_.create_plang_stmt_
      : reinterpret_cast< ::pg_query::CreatePLangStmt&>(::pg_query::_CreatePLangStmt_default_instance_);
}
inline const ::pg_query::CreatePLangStmt& Node::create_plang_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_plang_stmt)
  return _internal_create_plang_stmt();
}
inline ::pg_query::CreatePLangStmt* Node::unsafe_arena_release_create_plang_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_plang_stmt)
  if (_internal_has_create_plang_stmt()) {
    clear_has_node();
    ::pg_query::CreatePLangStmt* temp = node_.create_plang_stmt_;
    node_.create_plang_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_plang_stmt(::pg_query::CreatePLangStmt* create_plang_stmt) {
  clear_node();
  if (create_plang_stmt) {
    set_has_create_plang_stmt();
    node_.create_plang_stmt_ = create_plang_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_plang_stmt)
}
inline ::pg_query::CreatePLangStmt* Node::_internal_mutable_create_plang_stmt() {
  if (!_internal_has_create_plang_stmt()) {
    clear_node();
    set_has_create_plang_stmt();
    node_.create_plang_stmt_ = CreateMaybeMessage< ::pg_query::CreatePLangStmt >(GetArena());
  }
  return node_.create_plang_stmt_;
}
inline ::pg_query::CreatePLangStmt* Node::mutable_create_plang_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_plang_stmt)
  return _internal_mutable_create_plang_stmt();
}

// .pg_query.CreateRoleStmt create_role_stmt = 99 [json_name = "CreateRoleStmt"];
inline bool Node::_internal_has_create_role_stmt() const {
  return node_case() == kCreateRoleStmt;
}
inline bool Node::has_create_role_stmt() const {
  return _internal_has_create_role_stmt();
}
inline void Node::set_has_create_role_stmt() {
  _oneof_case_[0] = kCreateRoleStmt;
}
inline void Node::clear_create_role_stmt() {
  if (_internal_has_create_role_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_role_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateRoleStmt* Node::release_create_role_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_role_stmt)
  if (_internal_has_create_role_stmt()) {
    clear_has_node();
      ::pg_query::CreateRoleStmt* temp = node_.create_role_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateRoleStmt& Node::_internal_create_role_stmt() const {
  return _internal_has_create_role_stmt()
      ? *node_.create_role_stmt_
      : reinterpret_cast< ::pg_query::CreateRoleStmt&>(::pg_query::_CreateRoleStmt_default_instance_);
}
inline const ::pg_query::CreateRoleStmt& Node::create_role_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_role_stmt)
  return _internal_create_role_stmt();
}
inline ::pg_query::CreateRoleStmt* Node::unsafe_arena_release_create_role_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_role_stmt)
  if (_internal_has_create_role_stmt()) {
    clear_has_node();
    ::pg_query::CreateRoleStmt* temp = node_.create_role_stmt_;
    node_.create_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_role_stmt(::pg_query::CreateRoleStmt* create_role_stmt) {
  clear_node();
  if (create_role_stmt) {
    set_has_create_role_stmt();
    node_.create_role_stmt_ = create_role_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_role_stmt)
}
inline ::pg_query::CreateRoleStmt* Node::_internal_mutable_create_role_stmt() {
  if (!_internal_has_create_role_stmt()) {
    clear_node();
    set_has_create_role_stmt();
    node_.create_role_stmt_ = CreateMaybeMessage< ::pg_query::CreateRoleStmt >(GetArena());
  }
  return node_.create_role_stmt_;
}
inline ::pg_query::CreateRoleStmt* Node::mutable_create_role_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_role_stmt)
  return _internal_mutable_create_role_stmt();
}

// .pg_query.AlterRoleStmt alter_role_stmt = 100 [json_name = "AlterRoleStmt"];
inline bool Node::_internal_has_alter_role_stmt() const {
  return node_case() == kAlterRoleStmt;
}
inline bool Node::has_alter_role_stmt() const {
  return _internal_has_alter_role_stmt();
}
inline void Node::set_has_alter_role_stmt() {
  _oneof_case_[0] = kAlterRoleStmt;
}
inline void Node::clear_alter_role_stmt() {
  if (_internal_has_alter_role_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_role_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterRoleStmt* Node::release_alter_role_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_role_stmt)
  if (_internal_has_alter_role_stmt()) {
    clear_has_node();
      ::pg_query::AlterRoleStmt* temp = node_.alter_role_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterRoleStmt& Node::_internal_alter_role_stmt() const {
  return _internal_has_alter_role_stmt()
      ? *node_.alter_role_stmt_
      : reinterpret_cast< ::pg_query::AlterRoleStmt&>(::pg_query::_AlterRoleStmt_default_instance_);
}
inline const ::pg_query::AlterRoleStmt& Node::alter_role_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_role_stmt)
  return _internal_alter_role_stmt();
}
inline ::pg_query::AlterRoleStmt* Node::unsafe_arena_release_alter_role_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_role_stmt)
  if (_internal_has_alter_role_stmt()) {
    clear_has_node();
    ::pg_query::AlterRoleStmt* temp = node_.alter_role_stmt_;
    node_.alter_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_role_stmt(::pg_query::AlterRoleStmt* alter_role_stmt) {
  clear_node();
  if (alter_role_stmt) {
    set_has_alter_role_stmt();
    node_.alter_role_stmt_ = alter_role_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_role_stmt)
}
inline ::pg_query::AlterRoleStmt* Node::_internal_mutable_alter_role_stmt() {
  if (!_internal_has_alter_role_stmt()) {
    clear_node();
    set_has_alter_role_stmt();
    node_.alter_role_stmt_ = CreateMaybeMessage< ::pg_query::AlterRoleStmt >(GetArena());
  }
  return node_.alter_role_stmt_;
}
inline ::pg_query::AlterRoleStmt* Node::mutable_alter_role_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_role_stmt)
  return _internal_mutable_alter_role_stmt();
}

// .pg_query.DropRoleStmt drop_role_stmt = 101 [json_name = "DropRoleStmt"];
inline bool Node::_internal_has_drop_role_stmt() const {
  return node_case() == kDropRoleStmt;
}
inline bool Node::has_drop_role_stmt() const {
  return _internal_has_drop_role_stmt();
}
inline void Node::set_has_drop_role_stmt() {
  _oneof_case_[0] = kDropRoleStmt;
}
inline void Node::clear_drop_role_stmt() {
  if (_internal_has_drop_role_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.drop_role_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DropRoleStmt* Node::release_drop_role_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.drop_role_stmt)
  if (_internal_has_drop_role_stmt()) {
    clear_has_node();
      ::pg_query::DropRoleStmt* temp = node_.drop_role_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.drop_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropRoleStmt& Node::_internal_drop_role_stmt() const {
  return _internal_has_drop_role_stmt()
      ? *node_.drop_role_stmt_
      : reinterpret_cast< ::pg_query::DropRoleStmt&>(::pg_query::_DropRoleStmt_default_instance_);
}
inline const ::pg_query::DropRoleStmt& Node::drop_role_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.drop_role_stmt)
  return _internal_drop_role_stmt();
}
inline ::pg_query::DropRoleStmt* Node::unsafe_arena_release_drop_role_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.drop_role_stmt)
  if (_internal_has_drop_role_stmt()) {
    clear_has_node();
    ::pg_query::DropRoleStmt* temp = node_.drop_role_stmt_;
    node_.drop_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_drop_role_stmt(::pg_query::DropRoleStmt* drop_role_stmt) {
  clear_node();
  if (drop_role_stmt) {
    set_has_drop_role_stmt();
    node_.drop_role_stmt_ = drop_role_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.drop_role_stmt)
}
inline ::pg_query::DropRoleStmt* Node::_internal_mutable_drop_role_stmt() {
  if (!_internal_has_drop_role_stmt()) {
    clear_node();
    set_has_drop_role_stmt();
    node_.drop_role_stmt_ = CreateMaybeMessage< ::pg_query::DropRoleStmt >(GetArena());
  }
  return node_.drop_role_stmt_;
}
inline ::pg_query::DropRoleStmt* Node::mutable_drop_role_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_role_stmt)
  return _internal_mutable_drop_role_stmt();
}

// .pg_query.LockStmt lock_stmt = 102 [json_name = "LockStmt"];
inline bool Node::_internal_has_lock_stmt() const {
  return node_case() == kLockStmt;
}
inline bool Node::has_lock_stmt() const {
  return _internal_has_lock_stmt();
}
inline void Node::set_has_lock_stmt() {
  _oneof_case_[0] = kLockStmt;
}
inline void Node::clear_lock_stmt() {
  if (_internal_has_lock_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.lock_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::LockStmt* Node::release_lock_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.lock_stmt)
  if (_internal_has_lock_stmt()) {
    clear_has_node();
      ::pg_query::LockStmt* temp = node_.lock_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.lock_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::LockStmt& Node::_internal_lock_stmt() const {
  return _internal_has_lock_stmt()
      ? *node_.lock_stmt_
      : reinterpret_cast< ::pg_query::LockStmt&>(::pg_query::_LockStmt_default_instance_);
}
inline const ::pg_query::LockStmt& Node::lock_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.lock_stmt)
  return _internal_lock_stmt();
}
inline ::pg_query::LockStmt* Node::unsafe_arena_release_lock_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.lock_stmt)
  if (_internal_has_lock_stmt()) {
    clear_has_node();
    ::pg_query::LockStmt* temp = node_.lock_stmt_;
    node_.lock_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_lock_stmt(::pg_query::LockStmt* lock_stmt) {
  clear_node();
  if (lock_stmt) {
    set_has_lock_stmt();
    node_.lock_stmt_ = lock_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.lock_stmt)
}
inline ::pg_query::LockStmt* Node::_internal_mutable_lock_stmt() {
  if (!_internal_has_lock_stmt()) {
    clear_node();
    set_has_lock_stmt();
    node_.lock_stmt_ = CreateMaybeMessage< ::pg_query::LockStmt >(GetArena());
  }
  return node_.lock_stmt_;
}
inline ::pg_query::LockStmt* Node::mutable_lock_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.lock_stmt)
  return _internal_mutable_lock_stmt();
}

// .pg_query.ConstraintsSetStmt constraints_set_stmt = 103 [json_name = "ConstraintsSetStmt"];
inline bool Node::_internal_has_constraints_set_stmt() const {
  return node_case() == kConstraintsSetStmt;
}
inline bool Node::has_constraints_set_stmt() const {
  return _internal_has_constraints_set_stmt();
}
inline void Node::set_has_constraints_set_stmt() {
  _oneof_case_[0] = kConstraintsSetStmt;
}
inline void Node::clear_constraints_set_stmt() {
  if (_internal_has_constraints_set_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.constraints_set_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ConstraintsSetStmt* Node::release_constraints_set_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.constraints_set_stmt)
  if (_internal_has_constraints_set_stmt()) {
    clear_has_node();
      ::pg_query::ConstraintsSetStmt* temp = node_.constraints_set_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.constraints_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ConstraintsSetStmt& Node::_internal_constraints_set_stmt() const {
  return _internal_has_constraints_set_stmt()
      ? *node_.constraints_set_stmt_
      : reinterpret_cast< ::pg_query::ConstraintsSetStmt&>(::pg_query::_ConstraintsSetStmt_default_instance_);
}
inline const ::pg_query::ConstraintsSetStmt& Node::constraints_set_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.constraints_set_stmt)
  return _internal_constraints_set_stmt();
}
inline ::pg_query::ConstraintsSetStmt* Node::unsafe_arena_release_constraints_set_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.constraints_set_stmt)
  if (_internal_has_constraints_set_stmt()) {
    clear_has_node();
    ::pg_query::ConstraintsSetStmt* temp = node_.constraints_set_stmt_;
    node_.constraints_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_constraints_set_stmt(::pg_query::ConstraintsSetStmt* constraints_set_stmt) {
  clear_node();
  if (constraints_set_stmt) {
    set_has_constraints_set_stmt();
    node_.constraints_set_stmt_ = constraints_set_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.constraints_set_stmt)
}
inline ::pg_query::ConstraintsSetStmt* Node::_internal_mutable_constraints_set_stmt() {
  if (!_internal_has_constraints_set_stmt()) {
    clear_node();
    set_has_constraints_set_stmt();
    node_.constraints_set_stmt_ = CreateMaybeMessage< ::pg_query::ConstraintsSetStmt >(GetArena());
  }
  return node_.constraints_set_stmt_;
}
inline ::pg_query::ConstraintsSetStmt* Node::mutable_constraints_set_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.constraints_set_stmt)
  return _internal_mutable_constraints_set_stmt();
}

// .pg_query.ReindexStmt reindex_stmt = 104 [json_name = "ReindexStmt"];
inline bool Node::_internal_has_reindex_stmt() const {
  return node_case() == kReindexStmt;
}
inline bool Node::has_reindex_stmt() const {
  return _internal_has_reindex_stmt();
}
inline void Node::set_has_reindex_stmt() {
  _oneof_case_[0] = kReindexStmt;
}
inline void Node::clear_reindex_stmt() {
  if (_internal_has_reindex_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.reindex_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ReindexStmt* Node::release_reindex_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.reindex_stmt)
  if (_internal_has_reindex_stmt()) {
    clear_has_node();
      ::pg_query::ReindexStmt* temp = node_.reindex_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.reindex_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ReindexStmt& Node::_internal_reindex_stmt() const {
  return _internal_has_reindex_stmt()
      ? *node_.reindex_stmt_
      : reinterpret_cast< ::pg_query::ReindexStmt&>(::pg_query::_ReindexStmt_default_instance_);
}
inline const ::pg_query::ReindexStmt& Node::reindex_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.reindex_stmt)
  return _internal_reindex_stmt();
}
inline ::pg_query::ReindexStmt* Node::unsafe_arena_release_reindex_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.reindex_stmt)
  if (_internal_has_reindex_stmt()) {
    clear_has_node();
    ::pg_query::ReindexStmt* temp = node_.reindex_stmt_;
    node_.reindex_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_reindex_stmt(::pg_query::ReindexStmt* reindex_stmt) {
  clear_node();
  if (reindex_stmt) {
    set_has_reindex_stmt();
    node_.reindex_stmt_ = reindex_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.reindex_stmt)
}
inline ::pg_query::ReindexStmt* Node::_internal_mutable_reindex_stmt() {
  if (!_internal_has_reindex_stmt()) {
    clear_node();
    set_has_reindex_stmt();
    node_.reindex_stmt_ = CreateMaybeMessage< ::pg_query::ReindexStmt >(GetArena());
  }
  return node_.reindex_stmt_;
}
inline ::pg_query::ReindexStmt* Node::mutable_reindex_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.reindex_stmt)
  return _internal_mutable_reindex_stmt();
}

// .pg_query.CheckPointStmt check_point_stmt = 105 [json_name = "CheckPointStmt"];
inline bool Node::_internal_has_check_point_stmt() const {
  return node_case() == kCheckPointStmt;
}
inline bool Node::has_check_point_stmt() const {
  return _internal_has_check_point_stmt();
}
inline void Node::set_has_check_point_stmt() {
  _oneof_case_[0] = kCheckPointStmt;
}
inline void Node::clear_check_point_stmt() {
  if (_internal_has_check_point_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.check_point_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CheckPointStmt* Node::release_check_point_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.check_point_stmt)
  if (_internal_has_check_point_stmt()) {
    clear_has_node();
      ::pg_query::CheckPointStmt* temp = node_.check_point_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.check_point_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CheckPointStmt& Node::_internal_check_point_stmt() const {
  return _internal_has_check_point_stmt()
      ? *node_.check_point_stmt_
      : reinterpret_cast< ::pg_query::CheckPointStmt&>(::pg_query::_CheckPointStmt_default_instance_);
}
inline const ::pg_query::CheckPointStmt& Node::check_point_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.check_point_stmt)
  return _internal_check_point_stmt();
}
inline ::pg_query::CheckPointStmt* Node::unsafe_arena_release_check_point_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.check_point_stmt)
  if (_internal_has_check_point_stmt()) {
    clear_has_node();
    ::pg_query::CheckPointStmt* temp = node_.check_point_stmt_;
    node_.check_point_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_check_point_stmt(::pg_query::CheckPointStmt* check_point_stmt) {
  clear_node();
  if (check_point_stmt) {
    set_has_check_point_stmt();
    node_.check_point_stmt_ = check_point_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.check_point_stmt)
}
inline ::pg_query::CheckPointStmt* Node::_internal_mutable_check_point_stmt() {
  if (!_internal_has_check_point_stmt()) {
    clear_node();
    set_has_check_point_stmt();
    node_.check_point_stmt_ = CreateMaybeMessage< ::pg_query::CheckPointStmt >(GetArena());
  }
  return node_.check_point_stmt_;
}
inline ::pg_query::CheckPointStmt* Node::mutable_check_point_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.check_point_stmt)
  return _internal_mutable_check_point_stmt();
}

// .pg_query.CreateSchemaStmt create_schema_stmt = 106 [json_name = "CreateSchemaStmt"];
inline bool Node::_internal_has_create_schema_stmt() const {
  return node_case() == kCreateSchemaStmt;
}
inline bool Node::has_create_schema_stmt() const {
  return _internal_has_create_schema_stmt();
}
inline void Node::set_has_create_schema_stmt() {
  _oneof_case_[0] = kCreateSchemaStmt;
}
inline void Node::clear_create_schema_stmt() {
  if (_internal_has_create_schema_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_schema_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateSchemaStmt* Node::release_create_schema_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_schema_stmt)
  if (_internal_has_create_schema_stmt()) {
    clear_has_node();
      ::pg_query::CreateSchemaStmt* temp = node_.create_schema_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_schema_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateSchemaStmt& Node::_internal_create_schema_stmt() const {
  return _internal_has_create_schema_stmt()
      ? *node_.create_schema_stmt_
      : reinterpret_cast< ::pg_query::CreateSchemaStmt&>(::pg_query::_CreateSchemaStmt_default_instance_);
}
inline const ::pg_query::CreateSchemaStmt& Node::create_schema_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_schema_stmt)
  return _internal_create_schema_stmt();
}
inline ::pg_query::CreateSchemaStmt* Node::unsafe_arena_release_create_schema_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_schema_stmt)
  if (_internal_has_create_schema_stmt()) {
    clear_has_node();
    ::pg_query::CreateSchemaStmt* temp = node_.create_schema_stmt_;
    node_.create_schema_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_schema_stmt(::pg_query::CreateSchemaStmt* create_schema_stmt) {
  clear_node();
  if (create_schema_stmt) {
    set_has_create_schema_stmt();
    node_.create_schema_stmt_ = create_schema_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_schema_stmt)
}
inline ::pg_query::CreateSchemaStmt* Node::_internal_mutable_create_schema_stmt() {
  if (!_internal_has_create_schema_stmt()) {
    clear_node();
    set_has_create_schema_stmt();
    node_.create_schema_stmt_ = CreateMaybeMessage< ::pg_query::CreateSchemaStmt >(GetArena());
  }
  return node_.create_schema_stmt_;
}
inline ::pg_query::CreateSchemaStmt* Node::mutable_create_schema_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_schema_stmt)
  return _internal_mutable_create_schema_stmt();
}

// .pg_query.AlterDatabaseStmt alter_database_stmt = 107 [json_name = "AlterDatabaseStmt"];
inline bool Node::_internal_has_alter_database_stmt() const {
  return node_case() == kAlterDatabaseStmt;
}
inline bool Node::has_alter_database_stmt() const {
  return _internal_has_alter_database_stmt();
}
inline void Node::set_has_alter_database_stmt() {
  _oneof_case_[0] = kAlterDatabaseStmt;
}
inline void Node::clear_alter_database_stmt() {
  if (_internal_has_alter_database_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_database_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterDatabaseStmt* Node::release_alter_database_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_database_stmt)
  if (_internal_has_alter_database_stmt()) {
    clear_has_node();
      ::pg_query::AlterDatabaseStmt* temp = node_.alter_database_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_database_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterDatabaseStmt& Node::_internal_alter_database_stmt() const {
  return _internal_has_alter_database_stmt()
      ? *node_.alter_database_stmt_
      : reinterpret_cast< ::pg_query::AlterDatabaseStmt&>(::pg_query::_AlterDatabaseStmt_default_instance_);
}
inline const ::pg_query::AlterDatabaseStmt& Node::alter_database_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_database_stmt)
  return _internal_alter_database_stmt();
}
inline ::pg_query::AlterDatabaseStmt* Node::unsafe_arena_release_alter_database_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_database_stmt)
  if (_internal_has_alter_database_stmt()) {
    clear_has_node();
    ::pg_query::AlterDatabaseStmt* temp = node_.alter_database_stmt_;
    node_.alter_database_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_database_stmt(::pg_query::AlterDatabaseStmt* alter_database_stmt) {
  clear_node();
  if (alter_database_stmt) {
    set_has_alter_database_stmt();
    node_.alter_database_stmt_ = alter_database_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_database_stmt)
}
inline ::pg_query::AlterDatabaseStmt* Node::_internal_mutable_alter_database_stmt() {
  if (!_internal_has_alter_database_stmt()) {
    clear_node();
    set_has_alter_database_stmt();
    node_.alter_database_stmt_ = CreateMaybeMessage< ::pg_query::AlterDatabaseStmt >(GetArena());
  }
  return node_.alter_database_stmt_;
}
inline ::pg_query::AlterDatabaseStmt* Node::mutable_alter_database_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_database_stmt)
  return _internal_mutable_alter_database_stmt();
}

// .pg_query.AlterDatabaseSetStmt alter_database_set_stmt = 108 [json_name = "AlterDatabaseSetStmt"];
inline bool Node::_internal_has_alter_database_set_stmt() const {
  return node_case() == kAlterDatabaseSetStmt;
}
inline bool Node::has_alter_database_set_stmt() const {
  return _internal_has_alter_database_set_stmt();
}
inline void Node::set_has_alter_database_set_stmt() {
  _oneof_case_[0] = kAlterDatabaseSetStmt;
}
inline void Node::clear_alter_database_set_stmt() {
  if (_internal_has_alter_database_set_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_database_set_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterDatabaseSetStmt* Node::release_alter_database_set_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_database_set_stmt)
  if (_internal_has_alter_database_set_stmt()) {
    clear_has_node();
      ::pg_query::AlterDatabaseSetStmt* temp = node_.alter_database_set_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_database_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterDatabaseSetStmt& Node::_internal_alter_database_set_stmt() const {
  return _internal_has_alter_database_set_stmt()
      ? *node_.alter_database_set_stmt_
      : reinterpret_cast< ::pg_query::AlterDatabaseSetStmt&>(::pg_query::_AlterDatabaseSetStmt_default_instance_);
}
inline const ::pg_query::AlterDatabaseSetStmt& Node::alter_database_set_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_database_set_stmt)
  return _internal_alter_database_set_stmt();
}
inline ::pg_query::AlterDatabaseSetStmt* Node::unsafe_arena_release_alter_database_set_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_database_set_stmt)
  if (_internal_has_alter_database_set_stmt()) {
    clear_has_node();
    ::pg_query::AlterDatabaseSetStmt* temp = node_.alter_database_set_stmt_;
    node_.alter_database_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_database_set_stmt(::pg_query::AlterDatabaseSetStmt* alter_database_set_stmt) {
  clear_node();
  if (alter_database_set_stmt) {
    set_has_alter_database_set_stmt();
    node_.alter_database_set_stmt_ = alter_database_set_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_database_set_stmt)
}
inline ::pg_query::AlterDatabaseSetStmt* Node::_internal_mutable_alter_database_set_stmt() {
  if (!_internal_has_alter_database_set_stmt()) {
    clear_node();
    set_has_alter_database_set_stmt();
    node_.alter_database_set_stmt_ = CreateMaybeMessage< ::pg_query::AlterDatabaseSetStmt >(GetArena());
  }
  return node_.alter_database_set_stmt_;
}
inline ::pg_query::AlterDatabaseSetStmt* Node::mutable_alter_database_set_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_database_set_stmt)
  return _internal_mutable_alter_database_set_stmt();
}

// .pg_query.AlterRoleSetStmt alter_role_set_stmt = 109 [json_name = "AlterRoleSetStmt"];
inline bool Node::_internal_has_alter_role_set_stmt() const {
  return node_case() == kAlterRoleSetStmt;
}
inline bool Node::has_alter_role_set_stmt() const {
  return _internal_has_alter_role_set_stmt();
}
inline void Node::set_has_alter_role_set_stmt() {
  _oneof_case_[0] = kAlterRoleSetStmt;
}
inline void Node::clear_alter_role_set_stmt() {
  if (_internal_has_alter_role_set_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_role_set_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterRoleSetStmt* Node::release_alter_role_set_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_role_set_stmt)
  if (_internal_has_alter_role_set_stmt()) {
    clear_has_node();
      ::pg_query::AlterRoleSetStmt* temp = node_.alter_role_set_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_role_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterRoleSetStmt& Node::_internal_alter_role_set_stmt() const {
  return _internal_has_alter_role_set_stmt()
      ? *node_.alter_role_set_stmt_
      : reinterpret_cast< ::pg_query::AlterRoleSetStmt&>(::pg_query::_AlterRoleSetStmt_default_instance_);
}
inline const ::pg_query::AlterRoleSetStmt& Node::alter_role_set_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_role_set_stmt)
  return _internal_alter_role_set_stmt();
}
inline ::pg_query::AlterRoleSetStmt* Node::unsafe_arena_release_alter_role_set_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_role_set_stmt)
  if (_internal_has_alter_role_set_stmt()) {
    clear_has_node();
    ::pg_query::AlterRoleSetStmt* temp = node_.alter_role_set_stmt_;
    node_.alter_role_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_role_set_stmt(::pg_query::AlterRoleSetStmt* alter_role_set_stmt) {
  clear_node();
  if (alter_role_set_stmt) {
    set_has_alter_role_set_stmt();
    node_.alter_role_set_stmt_ = alter_role_set_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_role_set_stmt)
}
inline ::pg_query::AlterRoleSetStmt* Node::_internal_mutable_alter_role_set_stmt() {
  if (!_internal_has_alter_role_set_stmt()) {
    clear_node();
    set_has_alter_role_set_stmt();
    node_.alter_role_set_stmt_ = CreateMaybeMessage< ::pg_query::AlterRoleSetStmt >(GetArena());
  }
  return node_.alter_role_set_stmt_;
}
inline ::pg_query::AlterRoleSetStmt* Node::mutable_alter_role_set_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_role_set_stmt)
  return _internal_mutable_alter_role_set_stmt();
}

// .pg_query.CreateConversionStmt create_conversion_stmt = 110 [json_name = "CreateConversionStmt"];
inline bool Node::_internal_has_create_conversion_stmt() const {
  return node_case() == kCreateConversionStmt;
}
inline bool Node::has_create_conversion_stmt() const {
  return _internal_has_create_conversion_stmt();
}
inline void Node::set_has_create_conversion_stmt() {
  _oneof_case_[0] = kCreateConversionStmt;
}
inline void Node::clear_create_conversion_stmt() {
  if (_internal_has_create_conversion_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_conversion_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateConversionStmt* Node::release_create_conversion_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_conversion_stmt)
  if (_internal_has_create_conversion_stmt()) {
    clear_has_node();
      ::pg_query::CreateConversionStmt* temp = node_.create_conversion_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_conversion_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateConversionStmt& Node::_internal_create_conversion_stmt() const {
  return _internal_has_create_conversion_stmt()
      ? *node_.create_conversion_stmt_
      : reinterpret_cast< ::pg_query::CreateConversionStmt&>(::pg_query::_CreateConversionStmt_default_instance_);
}
inline const ::pg_query::CreateConversionStmt& Node::create_conversion_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_conversion_stmt)
  return _internal_create_conversion_stmt();
}
inline ::pg_query::CreateConversionStmt* Node::unsafe_arena_release_create_conversion_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_conversion_stmt)
  if (_internal_has_create_conversion_stmt()) {
    clear_has_node();
    ::pg_query::CreateConversionStmt* temp = node_.create_conversion_stmt_;
    node_.create_conversion_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_conversion_stmt(::pg_query::CreateConversionStmt* create_conversion_stmt) {
  clear_node();
  if (create_conversion_stmt) {
    set_has_create_conversion_stmt();
    node_.create_conversion_stmt_ = create_conversion_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_conversion_stmt)
}
inline ::pg_query::CreateConversionStmt* Node::_internal_mutable_create_conversion_stmt() {
  if (!_internal_has_create_conversion_stmt()) {
    clear_node();
    set_has_create_conversion_stmt();
    node_.create_conversion_stmt_ = CreateMaybeMessage< ::pg_query::CreateConversionStmt >(GetArena());
  }
  return node_.create_conversion_stmt_;
}
inline ::pg_query::CreateConversionStmt* Node::mutable_create_conversion_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_conversion_stmt)
  return _internal_mutable_create_conversion_stmt();
}

// .pg_query.CreateCastStmt create_cast_stmt = 111 [json_name = "CreateCastStmt"];
inline bool Node::_internal_has_create_cast_stmt() const {
  return node_case() == kCreateCastStmt;
}
inline bool Node::has_create_cast_stmt() const {
  return _internal_has_create_cast_stmt();
}
inline void Node::set_has_create_cast_stmt() {
  _oneof_case_[0] = kCreateCastStmt;
}
inline void Node::clear_create_cast_stmt() {
  if (_internal_has_create_cast_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_cast_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateCastStmt* Node::release_create_cast_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_cast_stmt)
  if (_internal_has_create_cast_stmt()) {
    clear_has_node();
      ::pg_query::CreateCastStmt* temp = node_.create_cast_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_cast_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateCastStmt& Node::_internal_create_cast_stmt() const {
  return _internal_has_create_cast_stmt()
      ? *node_.create_cast_stmt_
      : reinterpret_cast< ::pg_query::CreateCastStmt&>(::pg_query::_CreateCastStmt_default_instance_);
}
inline const ::pg_query::CreateCastStmt& Node::create_cast_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_cast_stmt)
  return _internal_create_cast_stmt();
}
inline ::pg_query::CreateCastStmt* Node::unsafe_arena_release_create_cast_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_cast_stmt)
  if (_internal_has_create_cast_stmt()) {
    clear_has_node();
    ::pg_query::CreateCastStmt* temp = node_.create_cast_stmt_;
    node_.create_cast_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_cast_stmt(::pg_query::CreateCastStmt* create_cast_stmt) {
  clear_node();
  if (create_cast_stmt) {
    set_has_create_cast_stmt();
    node_.create_cast_stmt_ = create_cast_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_cast_stmt)
}
inline ::pg_query::CreateCastStmt* Node::_internal_mutable_create_cast_stmt() {
  if (!_internal_has_create_cast_stmt()) {
    clear_node();
    set_has_create_cast_stmt();
    node_.create_cast_stmt_ = CreateMaybeMessage< ::pg_query::CreateCastStmt >(GetArena());
  }
  return node_.create_cast_stmt_;
}
inline ::pg_query::CreateCastStmt* Node::mutable_create_cast_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_cast_stmt)
  return _internal_mutable_create_cast_stmt();
}

// .pg_query.CreateOpClassStmt create_op_class_stmt = 112 [json_name = "CreateOpClassStmt"];
inline bool Node::_internal_has_create_op_class_stmt() const {
  return node_case() == kCreateOpClassStmt;
}
inline bool Node::has_create_op_class_stmt() const {
  return _internal_has_create_op_class_stmt();
}
inline void Node::set_has_create_op_class_stmt() {
  _oneof_case_[0] = kCreateOpClassStmt;
}
inline void Node::clear_create_op_class_stmt() {
  if (_internal_has_create_op_class_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_op_class_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateOpClassStmt* Node::release_create_op_class_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_op_class_stmt)
  if (_internal_has_create_op_class_stmt()) {
    clear_has_node();
      ::pg_query::CreateOpClassStmt* temp = node_.create_op_class_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_op_class_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateOpClassStmt& Node::_internal_create_op_class_stmt() const {
  return _internal_has_create_op_class_stmt()
      ? *node_.create_op_class_stmt_
      : reinterpret_cast< ::pg_query::CreateOpClassStmt&>(::pg_query::_CreateOpClassStmt_default_instance_);
}
inline const ::pg_query::CreateOpClassStmt& Node::create_op_class_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_op_class_stmt)
  return _internal_create_op_class_stmt();
}
inline ::pg_query::CreateOpClassStmt* Node::unsafe_arena_release_create_op_class_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_op_class_stmt)
  if (_internal_has_create_op_class_stmt()) {
    clear_has_node();
    ::pg_query::CreateOpClassStmt* temp = node_.create_op_class_stmt_;
    node_.create_op_class_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_op_class_stmt(::pg_query::CreateOpClassStmt* create_op_class_stmt) {
  clear_node();
  if (create_op_class_stmt) {
    set_has_create_op_class_stmt();
    node_.create_op_class_stmt_ = create_op_class_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_op_class_stmt)
}
inline ::pg_query::CreateOpClassStmt* Node::_internal_mutable_create_op_class_stmt() {
  if (!_internal_has_create_op_class_stmt()) {
    clear_node();
    set_has_create_op_class_stmt();
    node_.create_op_class_stmt_ = CreateMaybeMessage< ::pg_query::CreateOpClassStmt >(GetArena());
  }
  return node_.create_op_class_stmt_;
}
inline ::pg_query::CreateOpClassStmt* Node::mutable_create_op_class_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_op_class_stmt)
  return _internal_mutable_create_op_class_stmt();
}

// .pg_query.CreateOpFamilyStmt create_op_family_stmt = 113 [json_name = "CreateOpFamilyStmt"];
inline bool Node::_internal_has_create_op_family_stmt() const {
  return node_case() == kCreateOpFamilyStmt;
}
inline bool Node::has_create_op_family_stmt() const {
  return _internal_has_create_op_family_stmt();
}
inline void Node::set_has_create_op_family_stmt() {
  _oneof_case_[0] = kCreateOpFamilyStmt;
}
inline void Node::clear_create_op_family_stmt() {
  if (_internal_has_create_op_family_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_op_family_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateOpFamilyStmt* Node::release_create_op_family_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_op_family_stmt)
  if (_internal_has_create_op_family_stmt()) {
    clear_has_node();
      ::pg_query::CreateOpFamilyStmt* temp = node_.create_op_family_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_op_family_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateOpFamilyStmt& Node::_internal_create_op_family_stmt() const {
  return _internal_has_create_op_family_stmt()
      ? *node_.create_op_family_stmt_
      : reinterpret_cast< ::pg_query::CreateOpFamilyStmt&>(::pg_query::_CreateOpFamilyStmt_default_instance_);
}
inline const ::pg_query::CreateOpFamilyStmt& Node::create_op_family_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_op_family_stmt)
  return _internal_create_op_family_stmt();
}
inline ::pg_query::CreateOpFamilyStmt* Node::unsafe_arena_release_create_op_family_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_op_family_stmt)
  if (_internal_has_create_op_family_stmt()) {
    clear_has_node();
    ::pg_query::CreateOpFamilyStmt* temp = node_.create_op_family_stmt_;
    node_.create_op_family_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_op_family_stmt(::pg_query::CreateOpFamilyStmt* create_op_family_stmt) {
  clear_node();
  if (create_op_family_stmt) {
    set_has_create_op_family_stmt();
    node_.create_op_family_stmt_ = create_op_family_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_op_family_stmt)
}
inline ::pg_query::CreateOpFamilyStmt* Node::_internal_mutable_create_op_family_stmt() {
  if (!_internal_has_create_op_family_stmt()) {
    clear_node();
    set_has_create_op_family_stmt();
    node_.create_op_family_stmt_ = CreateMaybeMessage< ::pg_query::CreateOpFamilyStmt >(GetArena());
  }
  return node_.create_op_family_stmt_;
}
inline ::pg_query::CreateOpFamilyStmt* Node::mutable_create_op_family_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_op_family_stmt)
  return _internal_mutable_create_op_family_stmt();
}

// .pg_query.AlterOpFamilyStmt alter_op_family_stmt = 114 [json_name = "AlterOpFamilyStmt"];
inline bool Node::_internal_has_alter_op_family_stmt() const {
  return node_case() == kAlterOpFamilyStmt;
}
inline bool Node::has_alter_op_family_stmt() const {
  return _internal_has_alter_op_family_stmt();
}
inline void Node::set_has_alter_op_family_stmt() {
  _oneof_case_[0] = kAlterOpFamilyStmt;
}
inline void Node::clear_alter_op_family_stmt() {
  if (_internal_has_alter_op_family_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_op_family_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterOpFamilyStmt* Node::release_alter_op_family_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_op_family_stmt)
  if (_internal_has_alter_op_family_stmt()) {
    clear_has_node();
      ::pg_query::AlterOpFamilyStmt* temp = node_.alter_op_family_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_op_family_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterOpFamilyStmt& Node::_internal_alter_op_family_stmt() const {
  return _internal_has_alter_op_family_stmt()
      ? *node_.alter_op_family_stmt_
      : reinterpret_cast< ::pg_query::AlterOpFamilyStmt&>(::pg_query::_AlterOpFamilyStmt_default_instance_);
}
inline const ::pg_query::AlterOpFamilyStmt& Node::alter_op_family_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_op_family_stmt)
  return _internal_alter_op_family_stmt();
}
inline ::pg_query::AlterOpFamilyStmt* Node::unsafe_arena_release_alter_op_family_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_op_family_stmt)
  if (_internal_has_alter_op_family_stmt()) {
    clear_has_node();
    ::pg_query::AlterOpFamilyStmt* temp = node_.alter_op_family_stmt_;
    node_.alter_op_family_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_op_family_stmt(::pg_query::AlterOpFamilyStmt* alter_op_family_stmt) {
  clear_node();
  if (alter_op_family_stmt) {
    set_has_alter_op_family_stmt();
    node_.alter_op_family_stmt_ = alter_op_family_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_op_family_stmt)
}
inline ::pg_query::AlterOpFamilyStmt* Node::_internal_mutable_alter_op_family_stmt() {
  if (!_internal_has_alter_op_family_stmt()) {
    clear_node();
    set_has_alter_op_family_stmt();
    node_.alter_op_family_stmt_ = CreateMaybeMessage< ::pg_query::AlterOpFamilyStmt >(GetArena());
  }
  return node_.alter_op_family_stmt_;
}
inline ::pg_query::AlterOpFamilyStmt* Node::mutable_alter_op_family_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_op_family_stmt)
  return _internal_mutable_alter_op_family_stmt();
}

// .pg_query.PrepareStmt prepare_stmt = 115 [json_name = "PrepareStmt"];
inline bool Node::_internal_has_prepare_stmt() const {
  return node_case() == kPrepareStmt;
}
inline bool Node::has_prepare_stmt() const {
  return _internal_has_prepare_stmt();
}
inline void Node::set_has_prepare_stmt() {
  _oneof_case_[0] = kPrepareStmt;
}
inline void Node::clear_prepare_stmt() {
  if (_internal_has_prepare_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.prepare_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::PrepareStmt* Node::release_prepare_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.prepare_stmt)
  if (_internal_has_prepare_stmt()) {
    clear_has_node();
      ::pg_query::PrepareStmt* temp = node_.prepare_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.prepare_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PrepareStmt& Node::_internal_prepare_stmt() const {
  return _internal_has_prepare_stmt()
      ? *node_.prepare_stmt_
      : reinterpret_cast< ::pg_query::PrepareStmt&>(::pg_query::_PrepareStmt_default_instance_);
}
inline const ::pg_query::PrepareStmt& Node::prepare_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.prepare_stmt)
  return _internal_prepare_stmt();
}
inline ::pg_query::PrepareStmt* Node::unsafe_arena_release_prepare_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.prepare_stmt)
  if (_internal_has_prepare_stmt()) {
    clear_has_node();
    ::pg_query::PrepareStmt* temp = node_.prepare_stmt_;
    node_.prepare_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_prepare_stmt(::pg_query::PrepareStmt* prepare_stmt) {
  clear_node();
  if (prepare_stmt) {
    set_has_prepare_stmt();
    node_.prepare_stmt_ = prepare_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.prepare_stmt)
}
inline ::pg_query::PrepareStmt* Node::_internal_mutable_prepare_stmt() {
  if (!_internal_has_prepare_stmt()) {
    clear_node();
    set_has_prepare_stmt();
    node_.prepare_stmt_ = CreateMaybeMessage< ::pg_query::PrepareStmt >(GetArena());
  }
  return node_.prepare_stmt_;
}
inline ::pg_query::PrepareStmt* Node::mutable_prepare_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.prepare_stmt)
  return _internal_mutable_prepare_stmt();
}

// .pg_query.ExecuteStmt execute_stmt = 116 [json_name = "ExecuteStmt"];
inline bool Node::_internal_has_execute_stmt() const {
  return node_case() == kExecuteStmt;
}
inline bool Node::has_execute_stmt() const {
  return _internal_has_execute_stmt();
}
inline void Node::set_has_execute_stmt() {
  _oneof_case_[0] = kExecuteStmt;
}
inline void Node::clear_execute_stmt() {
  if (_internal_has_execute_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.execute_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ExecuteStmt* Node::release_execute_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.execute_stmt)
  if (_internal_has_execute_stmt()) {
    clear_has_node();
      ::pg_query::ExecuteStmt* temp = node_.execute_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.execute_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ExecuteStmt& Node::_internal_execute_stmt() const {
  return _internal_has_execute_stmt()
      ? *node_.execute_stmt_
      : reinterpret_cast< ::pg_query::ExecuteStmt&>(::pg_query::_ExecuteStmt_default_instance_);
}
inline const ::pg_query::ExecuteStmt& Node::execute_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.execute_stmt)
  return _internal_execute_stmt();
}
inline ::pg_query::ExecuteStmt* Node::unsafe_arena_release_execute_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.execute_stmt)
  if (_internal_has_execute_stmt()) {
    clear_has_node();
    ::pg_query::ExecuteStmt* temp = node_.execute_stmt_;
    node_.execute_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_execute_stmt(::pg_query::ExecuteStmt* execute_stmt) {
  clear_node();
  if (execute_stmt) {
    set_has_execute_stmt();
    node_.execute_stmt_ = execute_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.execute_stmt)
}
inline ::pg_query::ExecuteStmt* Node::_internal_mutable_execute_stmt() {
  if (!_internal_has_execute_stmt()) {
    clear_node();
    set_has_execute_stmt();
    node_.execute_stmt_ = CreateMaybeMessage< ::pg_query::ExecuteStmt >(GetArena());
  }
  return node_.execute_stmt_;
}
inline ::pg_query::ExecuteStmt* Node::mutable_execute_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.execute_stmt)
  return _internal_mutable_execute_stmt();
}

// .pg_query.DeallocateStmt deallocate_stmt = 117 [json_name = "DeallocateStmt"];
inline bool Node::_internal_has_deallocate_stmt() const {
  return node_case() == kDeallocateStmt;
}
inline bool Node::has_deallocate_stmt() const {
  return _internal_has_deallocate_stmt();
}
inline void Node::set_has_deallocate_stmt() {
  _oneof_case_[0] = kDeallocateStmt;
}
inline void Node::clear_deallocate_stmt() {
  if (_internal_has_deallocate_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.deallocate_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DeallocateStmt* Node::release_deallocate_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.deallocate_stmt)
  if (_internal_has_deallocate_stmt()) {
    clear_has_node();
      ::pg_query::DeallocateStmt* temp = node_.deallocate_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.deallocate_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DeallocateStmt& Node::_internal_deallocate_stmt() const {
  return _internal_has_deallocate_stmt()
      ? *node_.deallocate_stmt_
      : reinterpret_cast< ::pg_query::DeallocateStmt&>(::pg_query::_DeallocateStmt_default_instance_);
}
inline const ::pg_query::DeallocateStmt& Node::deallocate_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.deallocate_stmt)
  return _internal_deallocate_stmt();
}
inline ::pg_query::DeallocateStmt* Node::unsafe_arena_release_deallocate_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.deallocate_stmt)
  if (_internal_has_deallocate_stmt()) {
    clear_has_node();
    ::pg_query::DeallocateStmt* temp = node_.deallocate_stmt_;
    node_.deallocate_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_deallocate_stmt(::pg_query::DeallocateStmt* deallocate_stmt) {
  clear_node();
  if (deallocate_stmt) {
    set_has_deallocate_stmt();
    node_.deallocate_stmt_ = deallocate_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.deallocate_stmt)
}
inline ::pg_query::DeallocateStmt* Node::_internal_mutable_deallocate_stmt() {
  if (!_internal_has_deallocate_stmt()) {
    clear_node();
    set_has_deallocate_stmt();
    node_.deallocate_stmt_ = CreateMaybeMessage< ::pg_query::DeallocateStmt >(GetArena());
  }
  return node_.deallocate_stmt_;
}
inline ::pg_query::DeallocateStmt* Node::mutable_deallocate_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.deallocate_stmt)
  return _internal_mutable_deallocate_stmt();
}

// .pg_query.DeclareCursorStmt declare_cursor_stmt = 118 [json_name = "DeclareCursorStmt"];
inline bool Node::_internal_has_declare_cursor_stmt() const {
  return node_case() == kDeclareCursorStmt;
}
inline bool Node::has_declare_cursor_stmt() const {
  return _internal_has_declare_cursor_stmt();
}
inline void Node::set_has_declare_cursor_stmt() {
  _oneof_case_[0] = kDeclareCursorStmt;
}
inline void Node::clear_declare_cursor_stmt() {
  if (_internal_has_declare_cursor_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.declare_cursor_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DeclareCursorStmt* Node::release_declare_cursor_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.declare_cursor_stmt)
  if (_internal_has_declare_cursor_stmt()) {
    clear_has_node();
      ::pg_query::DeclareCursorStmt* temp = node_.declare_cursor_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.declare_cursor_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DeclareCursorStmt& Node::_internal_declare_cursor_stmt() const {
  return _internal_has_declare_cursor_stmt()
      ? *node_.declare_cursor_stmt_
      : reinterpret_cast< ::pg_query::DeclareCursorStmt&>(::pg_query::_DeclareCursorStmt_default_instance_);
}
inline const ::pg_query::DeclareCursorStmt& Node::declare_cursor_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.declare_cursor_stmt)
  return _internal_declare_cursor_stmt();
}
inline ::pg_query::DeclareCursorStmt* Node::unsafe_arena_release_declare_cursor_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.declare_cursor_stmt)
  if (_internal_has_declare_cursor_stmt()) {
    clear_has_node();
    ::pg_query::DeclareCursorStmt* temp = node_.declare_cursor_stmt_;
    node_.declare_cursor_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_declare_cursor_stmt(::pg_query::DeclareCursorStmt* declare_cursor_stmt) {
  clear_node();
  if (declare_cursor_stmt) {
    set_has_declare_cursor_stmt();
    node_.declare_cursor_stmt_ = declare_cursor_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.declare_cursor_stmt)
}
inline ::pg_query::DeclareCursorStmt* Node::_internal_mutable_declare_cursor_stmt() {
  if (!_internal_has_declare_cursor_stmt()) {
    clear_node();
    set_has_declare_cursor_stmt();
    node_.declare_cursor_stmt_ = CreateMaybeMessage< ::pg_query::DeclareCursorStmt >(GetArena());
  }
  return node_.declare_cursor_stmt_;
}
inline ::pg_query::DeclareCursorStmt* Node::mutable_declare_cursor_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.declare_cursor_stmt)
  return _internal_mutable_declare_cursor_stmt();
}

// .pg_query.CreateTableSpaceStmt create_table_space_stmt = 119 [json_name = "CreateTableSpaceStmt"];
inline bool Node::_internal_has_create_table_space_stmt() const {
  return node_case() == kCreateTableSpaceStmt;
}
inline bool Node::has_create_table_space_stmt() const {
  return _internal_has_create_table_space_stmt();
}
inline void Node::set_has_create_table_space_stmt() {
  _oneof_case_[0] = kCreateTableSpaceStmt;
}
inline void Node::clear_create_table_space_stmt() {
  if (_internal_has_create_table_space_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_table_space_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateTableSpaceStmt* Node::release_create_table_space_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_table_space_stmt)
  if (_internal_has_create_table_space_stmt()) {
    clear_has_node();
      ::pg_query::CreateTableSpaceStmt* temp = node_.create_table_space_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_table_space_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateTableSpaceStmt& Node::_internal_create_table_space_stmt() const {
  return _internal_has_create_table_space_stmt()
      ? *node_.create_table_space_stmt_
      : reinterpret_cast< ::pg_query::CreateTableSpaceStmt&>(::pg_query::_CreateTableSpaceStmt_default_instance_);
}
inline const ::pg_query::CreateTableSpaceStmt& Node::create_table_space_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_table_space_stmt)
  return _internal_create_table_space_stmt();
}
inline ::pg_query::CreateTableSpaceStmt* Node::unsafe_arena_release_create_table_space_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_table_space_stmt)
  if (_internal_has_create_table_space_stmt()) {
    clear_has_node();
    ::pg_query::CreateTableSpaceStmt* temp = node_.create_table_space_stmt_;
    node_.create_table_space_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_table_space_stmt(::pg_query::CreateTableSpaceStmt* create_table_space_stmt) {
  clear_node();
  if (create_table_space_stmt) {
    set_has_create_table_space_stmt();
    node_.create_table_space_stmt_ = create_table_space_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_table_space_stmt)
}
inline ::pg_query::CreateTableSpaceStmt* Node::_internal_mutable_create_table_space_stmt() {
  if (!_internal_has_create_table_space_stmt()) {
    clear_node();
    set_has_create_table_space_stmt();
    node_.create_table_space_stmt_ = CreateMaybeMessage< ::pg_query::CreateTableSpaceStmt >(GetArena());
  }
  return node_.create_table_space_stmt_;
}
inline ::pg_query::CreateTableSpaceStmt* Node::mutable_create_table_space_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_table_space_stmt)
  return _internal_mutable_create_table_space_stmt();
}

// .pg_query.DropTableSpaceStmt drop_table_space_stmt = 120 [json_name = "DropTableSpaceStmt"];
inline bool Node::_internal_has_drop_table_space_stmt() const {
  return node_case() == kDropTableSpaceStmt;
}
inline bool Node::has_drop_table_space_stmt() const {
  return _internal_has_drop_table_space_stmt();
}
inline void Node::set_has_drop_table_space_stmt() {
  _oneof_case_[0] = kDropTableSpaceStmt;
}
inline void Node::clear_drop_table_space_stmt() {
  if (_internal_has_drop_table_space_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.drop_table_space_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DropTableSpaceStmt* Node::release_drop_table_space_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.drop_table_space_stmt)
  if (_internal_has_drop_table_space_stmt()) {
    clear_has_node();
      ::pg_query::DropTableSpaceStmt* temp = node_.drop_table_space_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.drop_table_space_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropTableSpaceStmt& Node::_internal_drop_table_space_stmt() const {
  return _internal_has_drop_table_space_stmt()
      ? *node_.drop_table_space_stmt_
      : reinterpret_cast< ::pg_query::DropTableSpaceStmt&>(::pg_query::_DropTableSpaceStmt_default_instance_);
}
inline const ::pg_query::DropTableSpaceStmt& Node::drop_table_space_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.drop_table_space_stmt)
  return _internal_drop_table_space_stmt();
}
inline ::pg_query::DropTableSpaceStmt* Node::unsafe_arena_release_drop_table_space_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.drop_table_space_stmt)
  if (_internal_has_drop_table_space_stmt()) {
    clear_has_node();
    ::pg_query::DropTableSpaceStmt* temp = node_.drop_table_space_stmt_;
    node_.drop_table_space_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_drop_table_space_stmt(::pg_query::DropTableSpaceStmt* drop_table_space_stmt) {
  clear_node();
  if (drop_table_space_stmt) {
    set_has_drop_table_space_stmt();
    node_.drop_table_space_stmt_ = drop_table_space_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.drop_table_space_stmt)
}
inline ::pg_query::DropTableSpaceStmt* Node::_internal_mutable_drop_table_space_stmt() {
  if (!_internal_has_drop_table_space_stmt()) {
    clear_node();
    set_has_drop_table_space_stmt();
    node_.drop_table_space_stmt_ = CreateMaybeMessage< ::pg_query::DropTableSpaceStmt >(GetArena());
  }
  return node_.drop_table_space_stmt_;
}
inline ::pg_query::DropTableSpaceStmt* Node::mutable_drop_table_space_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_table_space_stmt)
  return _internal_mutable_drop_table_space_stmt();
}

// .pg_query.AlterObjectDependsStmt alter_object_depends_stmt = 121 [json_name = "AlterObjectDependsStmt"];
inline bool Node::_internal_has_alter_object_depends_stmt() const {
  return node_case() == kAlterObjectDependsStmt;
}
inline bool Node::has_alter_object_depends_stmt() const {
  return _internal_has_alter_object_depends_stmt();
}
inline void Node::set_has_alter_object_depends_stmt() {
  _oneof_case_[0] = kAlterObjectDependsStmt;
}
inline void Node::clear_alter_object_depends_stmt() {
  if (_internal_has_alter_object_depends_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_object_depends_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterObjectDependsStmt* Node::release_alter_object_depends_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_object_depends_stmt)
  if (_internal_has_alter_object_depends_stmt()) {
    clear_has_node();
      ::pg_query::AlterObjectDependsStmt* temp = node_.alter_object_depends_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_object_depends_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterObjectDependsStmt& Node::_internal_alter_object_depends_stmt() const {
  return _internal_has_alter_object_depends_stmt()
      ? *node_.alter_object_depends_stmt_
      : reinterpret_cast< ::pg_query::AlterObjectDependsStmt&>(::pg_query::_AlterObjectDependsStmt_default_instance_);
}
inline const ::pg_query::AlterObjectDependsStmt& Node::alter_object_depends_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_object_depends_stmt)
  return _internal_alter_object_depends_stmt();
}
inline ::pg_query::AlterObjectDependsStmt* Node::unsafe_arena_release_alter_object_depends_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_object_depends_stmt)
  if (_internal_has_alter_object_depends_stmt()) {
    clear_has_node();
    ::pg_query::AlterObjectDependsStmt* temp = node_.alter_object_depends_stmt_;
    node_.alter_object_depends_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_object_depends_stmt(::pg_query::AlterObjectDependsStmt* alter_object_depends_stmt) {
  clear_node();
  if (alter_object_depends_stmt) {
    set_has_alter_object_depends_stmt();
    node_.alter_object_depends_stmt_ = alter_object_depends_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_object_depends_stmt)
}
inline ::pg_query::AlterObjectDependsStmt* Node::_internal_mutable_alter_object_depends_stmt() {
  if (!_internal_has_alter_object_depends_stmt()) {
    clear_node();
    set_has_alter_object_depends_stmt();
    node_.alter_object_depends_stmt_ = CreateMaybeMessage< ::pg_query::AlterObjectDependsStmt >(GetArena());
  }
  return node_.alter_object_depends_stmt_;
}
inline ::pg_query::AlterObjectDependsStmt* Node::mutable_alter_object_depends_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_object_depends_stmt)
  return _internal_mutable_alter_object_depends_stmt();
}

// .pg_query.AlterObjectSchemaStmt alter_object_schema_stmt = 122 [json_name = "AlterObjectSchemaStmt"];
inline bool Node::_internal_has_alter_object_schema_stmt() const {
  return node_case() == kAlterObjectSchemaStmt;
}
inline bool Node::has_alter_object_schema_stmt() const {
  return _internal_has_alter_object_schema_stmt();
}
inline void Node::set_has_alter_object_schema_stmt() {
  _oneof_case_[0] = kAlterObjectSchemaStmt;
}
inline void Node::clear_alter_object_schema_stmt() {
  if (_internal_has_alter_object_schema_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_object_schema_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterObjectSchemaStmt* Node::release_alter_object_schema_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_object_schema_stmt)
  if (_internal_has_alter_object_schema_stmt()) {
    clear_has_node();
      ::pg_query::AlterObjectSchemaStmt* temp = node_.alter_object_schema_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_object_schema_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterObjectSchemaStmt& Node::_internal_alter_object_schema_stmt() const {
  return _internal_has_alter_object_schema_stmt()
      ? *node_.alter_object_schema_stmt_
      : reinterpret_cast< ::pg_query::AlterObjectSchemaStmt&>(::pg_query::_AlterObjectSchemaStmt_default_instance_);
}
inline const ::pg_query::AlterObjectSchemaStmt& Node::alter_object_schema_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_object_schema_stmt)
  return _internal_alter_object_schema_stmt();
}
inline ::pg_query::AlterObjectSchemaStmt* Node::unsafe_arena_release_alter_object_schema_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_object_schema_stmt)
  if (_internal_has_alter_object_schema_stmt()) {
    clear_has_node();
    ::pg_query::AlterObjectSchemaStmt* temp = node_.alter_object_schema_stmt_;
    node_.alter_object_schema_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_object_schema_stmt(::pg_query::AlterObjectSchemaStmt* alter_object_schema_stmt) {
  clear_node();
  if (alter_object_schema_stmt) {
    set_has_alter_object_schema_stmt();
    node_.alter_object_schema_stmt_ = alter_object_schema_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_object_schema_stmt)
}
inline ::pg_query::AlterObjectSchemaStmt* Node::_internal_mutable_alter_object_schema_stmt() {
  if (!_internal_has_alter_object_schema_stmt()) {
    clear_node();
    set_has_alter_object_schema_stmt();
    node_.alter_object_schema_stmt_ = CreateMaybeMessage< ::pg_query::AlterObjectSchemaStmt >(GetArena());
  }
  return node_.alter_object_schema_stmt_;
}
inline ::pg_query::AlterObjectSchemaStmt* Node::mutable_alter_object_schema_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_object_schema_stmt)
  return _internal_mutable_alter_object_schema_stmt();
}

// .pg_query.AlterOwnerStmt alter_owner_stmt = 123 [json_name = "AlterOwnerStmt"];
inline bool Node::_internal_has_alter_owner_stmt() const {
  return node_case() == kAlterOwnerStmt;
}
inline bool Node::has_alter_owner_stmt() const {
  return _internal_has_alter_owner_stmt();
}
inline void Node::set_has_alter_owner_stmt() {
  _oneof_case_[0] = kAlterOwnerStmt;
}
inline void Node::clear_alter_owner_stmt() {
  if (_internal_has_alter_owner_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_owner_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterOwnerStmt* Node::release_alter_owner_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_owner_stmt)
  if (_internal_has_alter_owner_stmt()) {
    clear_has_node();
      ::pg_query::AlterOwnerStmt* temp = node_.alter_owner_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_owner_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterOwnerStmt& Node::_internal_alter_owner_stmt() const {
  return _internal_has_alter_owner_stmt()
      ? *node_.alter_owner_stmt_
      : reinterpret_cast< ::pg_query::AlterOwnerStmt&>(::pg_query::_AlterOwnerStmt_default_instance_);
}
inline const ::pg_query::AlterOwnerStmt& Node::alter_owner_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_owner_stmt)
  return _internal_alter_owner_stmt();
}
inline ::pg_query::AlterOwnerStmt* Node::unsafe_arena_release_alter_owner_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_owner_stmt)
  if (_internal_has_alter_owner_stmt()) {
    clear_has_node();
    ::pg_query::AlterOwnerStmt* temp = node_.alter_owner_stmt_;
    node_.alter_owner_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_owner_stmt(::pg_query::AlterOwnerStmt* alter_owner_stmt) {
  clear_node();
  if (alter_owner_stmt) {
    set_has_alter_owner_stmt();
    node_.alter_owner_stmt_ = alter_owner_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_owner_stmt)
}
inline ::pg_query::AlterOwnerStmt* Node::_internal_mutable_alter_owner_stmt() {
  if (!_internal_has_alter_owner_stmt()) {
    clear_node();
    set_has_alter_owner_stmt();
    node_.alter_owner_stmt_ = CreateMaybeMessage< ::pg_query::AlterOwnerStmt >(GetArena());
  }
  return node_.alter_owner_stmt_;
}
inline ::pg_query::AlterOwnerStmt* Node::mutable_alter_owner_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_owner_stmt)
  return _internal_mutable_alter_owner_stmt();
}

// .pg_query.AlterOperatorStmt alter_operator_stmt = 124 [json_name = "AlterOperatorStmt"];
inline bool Node::_internal_has_alter_operator_stmt() const {
  return node_case() == kAlterOperatorStmt;
}
inline bool Node::has_alter_operator_stmt() const {
  return _internal_has_alter_operator_stmt();
}
inline void Node::set_has_alter_operator_stmt() {
  _oneof_case_[0] = kAlterOperatorStmt;
}
inline void Node::clear_alter_operator_stmt() {
  if (_internal_has_alter_operator_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_operator_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterOperatorStmt* Node::release_alter_operator_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_operator_stmt)
  if (_internal_has_alter_operator_stmt()) {
    clear_has_node();
      ::pg_query::AlterOperatorStmt* temp = node_.alter_operator_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_operator_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterOperatorStmt& Node::_internal_alter_operator_stmt() const {
  return _internal_has_alter_operator_stmt()
      ? *node_.alter_operator_stmt_
      : reinterpret_cast< ::pg_query::AlterOperatorStmt&>(::pg_query::_AlterOperatorStmt_default_instance_);
}
inline const ::pg_query::AlterOperatorStmt& Node::alter_operator_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_operator_stmt)
  return _internal_alter_operator_stmt();
}
inline ::pg_query::AlterOperatorStmt* Node::unsafe_arena_release_alter_operator_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_operator_stmt)
  if (_internal_has_alter_operator_stmt()) {
    clear_has_node();
    ::pg_query::AlterOperatorStmt* temp = node_.alter_operator_stmt_;
    node_.alter_operator_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_operator_stmt(::pg_query::AlterOperatorStmt* alter_operator_stmt) {
  clear_node();
  if (alter_operator_stmt) {
    set_has_alter_operator_stmt();
    node_.alter_operator_stmt_ = alter_operator_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_operator_stmt)
}
inline ::pg_query::AlterOperatorStmt* Node::_internal_mutable_alter_operator_stmt() {
  if (!_internal_has_alter_operator_stmt()) {
    clear_node();
    set_has_alter_operator_stmt();
    node_.alter_operator_stmt_ = CreateMaybeMessage< ::pg_query::AlterOperatorStmt >(GetArena());
  }
  return node_.alter_operator_stmt_;
}
inline ::pg_query::AlterOperatorStmt* Node::mutable_alter_operator_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_operator_stmt)
  return _internal_mutable_alter_operator_stmt();
}

// .pg_query.AlterTypeStmt alter_type_stmt = 125 [json_name = "AlterTypeStmt"];
inline bool Node::_internal_has_alter_type_stmt() const {
  return node_case() == kAlterTypeStmt;
}
inline bool Node::has_alter_type_stmt() const {
  return _internal_has_alter_type_stmt();
}
inline void Node::set_has_alter_type_stmt() {
  _oneof_case_[0] = kAlterTypeStmt;
}
inline void Node::clear_alter_type_stmt() {
  if (_internal_has_alter_type_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_type_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterTypeStmt* Node::release_alter_type_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_type_stmt)
  if (_internal_has_alter_type_stmt()) {
    clear_has_node();
      ::pg_query::AlterTypeStmt* temp = node_.alter_type_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_type_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterTypeStmt& Node::_internal_alter_type_stmt() const {
  return _internal_has_alter_type_stmt()
      ? *node_.alter_type_stmt_
      : reinterpret_cast< ::pg_query::AlterTypeStmt&>(::pg_query::_AlterTypeStmt_default_instance_);
}
inline const ::pg_query::AlterTypeStmt& Node::alter_type_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_type_stmt)
  return _internal_alter_type_stmt();
}
inline ::pg_query::AlterTypeStmt* Node::unsafe_arena_release_alter_type_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_type_stmt)
  if (_internal_has_alter_type_stmt()) {
    clear_has_node();
    ::pg_query::AlterTypeStmt* temp = node_.alter_type_stmt_;
    node_.alter_type_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_type_stmt(::pg_query::AlterTypeStmt* alter_type_stmt) {
  clear_node();
  if (alter_type_stmt) {
    set_has_alter_type_stmt();
    node_.alter_type_stmt_ = alter_type_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_type_stmt)
}
inline ::pg_query::AlterTypeStmt* Node::_internal_mutable_alter_type_stmt() {
  if (!_internal_has_alter_type_stmt()) {
    clear_node();
    set_has_alter_type_stmt();
    node_.alter_type_stmt_ = CreateMaybeMessage< ::pg_query::AlterTypeStmt >(GetArena());
  }
  return node_.alter_type_stmt_;
}
inline ::pg_query::AlterTypeStmt* Node::mutable_alter_type_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_type_stmt)
  return _internal_mutable_alter_type_stmt();
}

// .pg_query.DropOwnedStmt drop_owned_stmt = 126 [json_name = "DropOwnedStmt"];
inline bool Node::_internal_has_drop_owned_stmt() const {
  return node_case() == kDropOwnedStmt;
}
inline bool Node::has_drop_owned_stmt() const {
  return _internal_has_drop_owned_stmt();
}
inline void Node::set_has_drop_owned_stmt() {
  _oneof_case_[0] = kDropOwnedStmt;
}
inline void Node::clear_drop_owned_stmt() {
  if (_internal_has_drop_owned_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.drop_owned_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DropOwnedStmt* Node::release_drop_owned_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.drop_owned_stmt)
  if (_internal_has_drop_owned_stmt()) {
    clear_has_node();
      ::pg_query::DropOwnedStmt* temp = node_.drop_owned_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.drop_owned_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropOwnedStmt& Node::_internal_drop_owned_stmt() const {
  return _internal_has_drop_owned_stmt()
      ? *node_.drop_owned_stmt_
      : reinterpret_cast< ::pg_query::DropOwnedStmt&>(::pg_query::_DropOwnedStmt_default_instance_);
}
inline const ::pg_query::DropOwnedStmt& Node::drop_owned_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.drop_owned_stmt)
  return _internal_drop_owned_stmt();
}
inline ::pg_query::DropOwnedStmt* Node::unsafe_arena_release_drop_owned_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.drop_owned_stmt)
  if (_internal_has_drop_owned_stmt()) {
    clear_has_node();
    ::pg_query::DropOwnedStmt* temp = node_.drop_owned_stmt_;
    node_.drop_owned_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_drop_owned_stmt(::pg_query::DropOwnedStmt* drop_owned_stmt) {
  clear_node();
  if (drop_owned_stmt) {
    set_has_drop_owned_stmt();
    node_.drop_owned_stmt_ = drop_owned_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.drop_owned_stmt)
}
inline ::pg_query::DropOwnedStmt* Node::_internal_mutable_drop_owned_stmt() {
  if (!_internal_has_drop_owned_stmt()) {
    clear_node();
    set_has_drop_owned_stmt();
    node_.drop_owned_stmt_ = CreateMaybeMessage< ::pg_query::DropOwnedStmt >(GetArena());
  }
  return node_.drop_owned_stmt_;
}
inline ::pg_query::DropOwnedStmt* Node::mutable_drop_owned_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_owned_stmt)
  return _internal_mutable_drop_owned_stmt();
}

// .pg_query.ReassignOwnedStmt reassign_owned_stmt = 127 [json_name = "ReassignOwnedStmt"];
inline bool Node::_internal_has_reassign_owned_stmt() const {
  return node_case() == kReassignOwnedStmt;
}
inline bool Node::has_reassign_owned_stmt() const {
  return _internal_has_reassign_owned_stmt();
}
inline void Node::set_has_reassign_owned_stmt() {
  _oneof_case_[0] = kReassignOwnedStmt;
}
inline void Node::clear_reassign_owned_stmt() {
  if (_internal_has_reassign_owned_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.reassign_owned_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ReassignOwnedStmt* Node::release_reassign_owned_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.reassign_owned_stmt)
  if (_internal_has_reassign_owned_stmt()) {
    clear_has_node();
      ::pg_query::ReassignOwnedStmt* temp = node_.reassign_owned_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.reassign_owned_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ReassignOwnedStmt& Node::_internal_reassign_owned_stmt() const {
  return _internal_has_reassign_owned_stmt()
      ? *node_.reassign_owned_stmt_
      : reinterpret_cast< ::pg_query::ReassignOwnedStmt&>(::pg_query::_ReassignOwnedStmt_default_instance_);
}
inline const ::pg_query::ReassignOwnedStmt& Node::reassign_owned_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.reassign_owned_stmt)
  return _internal_reassign_owned_stmt();
}
inline ::pg_query::ReassignOwnedStmt* Node::unsafe_arena_release_reassign_owned_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.reassign_owned_stmt)
  if (_internal_has_reassign_owned_stmt()) {
    clear_has_node();
    ::pg_query::ReassignOwnedStmt* temp = node_.reassign_owned_stmt_;
    node_.reassign_owned_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_reassign_owned_stmt(::pg_query::ReassignOwnedStmt* reassign_owned_stmt) {
  clear_node();
  if (reassign_owned_stmt) {
    set_has_reassign_owned_stmt();
    node_.reassign_owned_stmt_ = reassign_owned_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.reassign_owned_stmt)
}
inline ::pg_query::ReassignOwnedStmt* Node::_internal_mutable_reassign_owned_stmt() {
  if (!_internal_has_reassign_owned_stmt()) {
    clear_node();
    set_has_reassign_owned_stmt();
    node_.reassign_owned_stmt_ = CreateMaybeMessage< ::pg_query::ReassignOwnedStmt >(GetArena());
  }
  return node_.reassign_owned_stmt_;
}
inline ::pg_query::ReassignOwnedStmt* Node::mutable_reassign_owned_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.reassign_owned_stmt)
  return _internal_mutable_reassign_owned_stmt();
}

// .pg_query.CompositeTypeStmt composite_type_stmt = 128 [json_name = "CompositeTypeStmt"];
inline bool Node::_internal_has_composite_type_stmt() const {
  return node_case() == kCompositeTypeStmt;
}
inline bool Node::has_composite_type_stmt() const {
  return _internal_has_composite_type_stmt();
}
inline void Node::set_has_composite_type_stmt() {
  _oneof_case_[0] = kCompositeTypeStmt;
}
inline void Node::clear_composite_type_stmt() {
  if (_internal_has_composite_type_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.composite_type_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CompositeTypeStmt* Node::release_composite_type_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.composite_type_stmt)
  if (_internal_has_composite_type_stmt()) {
    clear_has_node();
      ::pg_query::CompositeTypeStmt* temp = node_.composite_type_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.composite_type_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CompositeTypeStmt& Node::_internal_composite_type_stmt() const {
  return _internal_has_composite_type_stmt()
      ? *node_.composite_type_stmt_
      : reinterpret_cast< ::pg_query::CompositeTypeStmt&>(::pg_query::_CompositeTypeStmt_default_instance_);
}
inline const ::pg_query::CompositeTypeStmt& Node::composite_type_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.composite_type_stmt)
  return _internal_composite_type_stmt();
}
inline ::pg_query::CompositeTypeStmt* Node::unsafe_arena_release_composite_type_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.composite_type_stmt)
  if (_internal_has_composite_type_stmt()) {
    clear_has_node();
    ::pg_query::CompositeTypeStmt* temp = node_.composite_type_stmt_;
    node_.composite_type_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_composite_type_stmt(::pg_query::CompositeTypeStmt* composite_type_stmt) {
  clear_node();
  if (composite_type_stmt) {
    set_has_composite_type_stmt();
    node_.composite_type_stmt_ = composite_type_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.composite_type_stmt)
}
inline ::pg_query::CompositeTypeStmt* Node::_internal_mutable_composite_type_stmt() {
  if (!_internal_has_composite_type_stmt()) {
    clear_node();
    set_has_composite_type_stmt();
    node_.composite_type_stmt_ = CreateMaybeMessage< ::pg_query::CompositeTypeStmt >(GetArena());
  }
  return node_.composite_type_stmt_;
}
inline ::pg_query::CompositeTypeStmt* Node::mutable_composite_type_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.composite_type_stmt)
  return _internal_mutable_composite_type_stmt();
}

// .pg_query.CreateEnumStmt create_enum_stmt = 129 [json_name = "CreateEnumStmt"];
inline bool Node::_internal_has_create_enum_stmt() const {
  return node_case() == kCreateEnumStmt;
}
inline bool Node::has_create_enum_stmt() const {
  return _internal_has_create_enum_stmt();
}
inline void Node::set_has_create_enum_stmt() {
  _oneof_case_[0] = kCreateEnumStmt;
}
inline void Node::clear_create_enum_stmt() {
  if (_internal_has_create_enum_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_enum_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateEnumStmt* Node::release_create_enum_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_enum_stmt)
  if (_internal_has_create_enum_stmt()) {
    clear_has_node();
      ::pg_query::CreateEnumStmt* temp = node_.create_enum_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_enum_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateEnumStmt& Node::_internal_create_enum_stmt() const {
  return _internal_has_create_enum_stmt()
      ? *node_.create_enum_stmt_
      : reinterpret_cast< ::pg_query::CreateEnumStmt&>(::pg_query::_CreateEnumStmt_default_instance_);
}
inline const ::pg_query::CreateEnumStmt& Node::create_enum_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_enum_stmt)
  return _internal_create_enum_stmt();
}
inline ::pg_query::CreateEnumStmt* Node::unsafe_arena_release_create_enum_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_enum_stmt)
  if (_internal_has_create_enum_stmt()) {
    clear_has_node();
    ::pg_query::CreateEnumStmt* temp = node_.create_enum_stmt_;
    node_.create_enum_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_enum_stmt(::pg_query::CreateEnumStmt* create_enum_stmt) {
  clear_node();
  if (create_enum_stmt) {
    set_has_create_enum_stmt();
    node_.create_enum_stmt_ = create_enum_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_enum_stmt)
}
inline ::pg_query::CreateEnumStmt* Node::_internal_mutable_create_enum_stmt() {
  if (!_internal_has_create_enum_stmt()) {
    clear_node();
    set_has_create_enum_stmt();
    node_.create_enum_stmt_ = CreateMaybeMessage< ::pg_query::CreateEnumStmt >(GetArena());
  }
  return node_.create_enum_stmt_;
}
inline ::pg_query::CreateEnumStmt* Node::mutable_create_enum_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_enum_stmt)
  return _internal_mutable_create_enum_stmt();
}

// .pg_query.CreateRangeStmt create_range_stmt = 130 [json_name = "CreateRangeStmt"];
inline bool Node::_internal_has_create_range_stmt() const {
  return node_case() == kCreateRangeStmt;
}
inline bool Node::has_create_range_stmt() const {
  return _internal_has_create_range_stmt();
}
inline void Node::set_has_create_range_stmt() {
  _oneof_case_[0] = kCreateRangeStmt;
}
inline void Node::clear_create_range_stmt() {
  if (_internal_has_create_range_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_range_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateRangeStmt* Node::release_create_range_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_range_stmt)
  if (_internal_has_create_range_stmt()) {
    clear_has_node();
      ::pg_query::CreateRangeStmt* temp = node_.create_range_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_range_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateRangeStmt& Node::_internal_create_range_stmt() const {
  return _internal_has_create_range_stmt()
      ? *node_.create_range_stmt_
      : reinterpret_cast< ::pg_query::CreateRangeStmt&>(::pg_query::_CreateRangeStmt_default_instance_);
}
inline const ::pg_query::CreateRangeStmt& Node::create_range_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_range_stmt)
  return _internal_create_range_stmt();
}
inline ::pg_query::CreateRangeStmt* Node::unsafe_arena_release_create_range_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_range_stmt)
  if (_internal_has_create_range_stmt()) {
    clear_has_node();
    ::pg_query::CreateRangeStmt* temp = node_.create_range_stmt_;
    node_.create_range_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_range_stmt(::pg_query::CreateRangeStmt* create_range_stmt) {
  clear_node();
  if (create_range_stmt) {
    set_has_create_range_stmt();
    node_.create_range_stmt_ = create_range_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_range_stmt)
}
inline ::pg_query::CreateRangeStmt* Node::_internal_mutable_create_range_stmt() {
  if (!_internal_has_create_range_stmt()) {
    clear_node();
    set_has_create_range_stmt();
    node_.create_range_stmt_ = CreateMaybeMessage< ::pg_query::CreateRangeStmt >(GetArena());
  }
  return node_.create_range_stmt_;
}
inline ::pg_query::CreateRangeStmt* Node::mutable_create_range_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_range_stmt)
  return _internal_mutable_create_range_stmt();
}

// .pg_query.AlterEnumStmt alter_enum_stmt = 131 [json_name = "AlterEnumStmt"];
inline bool Node::_internal_has_alter_enum_stmt() const {
  return node_case() == kAlterEnumStmt;
}
inline bool Node::has_alter_enum_stmt() const {
  return _internal_has_alter_enum_stmt();
}
inline void Node::set_has_alter_enum_stmt() {
  _oneof_case_[0] = kAlterEnumStmt;
}
inline void Node::clear_alter_enum_stmt() {
  if (_internal_has_alter_enum_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_enum_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterEnumStmt* Node::release_alter_enum_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_enum_stmt)
  if (_internal_has_alter_enum_stmt()) {
    clear_has_node();
      ::pg_query::AlterEnumStmt* temp = node_.alter_enum_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_enum_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterEnumStmt& Node::_internal_alter_enum_stmt() const {
  return _internal_has_alter_enum_stmt()
      ? *node_.alter_enum_stmt_
      : reinterpret_cast< ::pg_query::AlterEnumStmt&>(::pg_query::_AlterEnumStmt_default_instance_);
}
inline const ::pg_query::AlterEnumStmt& Node::alter_enum_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_enum_stmt)
  return _internal_alter_enum_stmt();
}
inline ::pg_query::AlterEnumStmt* Node::unsafe_arena_release_alter_enum_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_enum_stmt)
  if (_internal_has_alter_enum_stmt()) {
    clear_has_node();
    ::pg_query::AlterEnumStmt* temp = node_.alter_enum_stmt_;
    node_.alter_enum_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_enum_stmt(::pg_query::AlterEnumStmt* alter_enum_stmt) {
  clear_node();
  if (alter_enum_stmt) {
    set_has_alter_enum_stmt();
    node_.alter_enum_stmt_ = alter_enum_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_enum_stmt)
}
inline ::pg_query::AlterEnumStmt* Node::_internal_mutable_alter_enum_stmt() {
  if (!_internal_has_alter_enum_stmt()) {
    clear_node();
    set_has_alter_enum_stmt();
    node_.alter_enum_stmt_ = CreateMaybeMessage< ::pg_query::AlterEnumStmt >(GetArena());
  }
  return node_.alter_enum_stmt_;
}
inline ::pg_query::AlterEnumStmt* Node::mutable_alter_enum_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_enum_stmt)
  return _internal_mutable_alter_enum_stmt();
}

// .pg_query.AlterTSDictionaryStmt alter_tsdictionary_stmt = 132 [json_name = "AlterTSDictionaryStmt"];
inline bool Node::_internal_has_alter_tsdictionary_stmt() const {
  return node_case() == kAlterTsdictionaryStmt;
}
inline bool Node::has_alter_tsdictionary_stmt() const {
  return _internal_has_alter_tsdictionary_stmt();
}
inline void Node::set_has_alter_tsdictionary_stmt() {
  _oneof_case_[0] = kAlterTsdictionaryStmt;
}
inline void Node::clear_alter_tsdictionary_stmt() {
  if (_internal_has_alter_tsdictionary_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_tsdictionary_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterTSDictionaryStmt* Node::release_alter_tsdictionary_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_tsdictionary_stmt)
  if (_internal_has_alter_tsdictionary_stmt()) {
    clear_has_node();
      ::pg_query::AlterTSDictionaryStmt* temp = node_.alter_tsdictionary_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_tsdictionary_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterTSDictionaryStmt& Node::_internal_alter_tsdictionary_stmt() const {
  return _internal_has_alter_tsdictionary_stmt()
      ? *node_.alter_tsdictionary_stmt_
      : reinterpret_cast< ::pg_query::AlterTSDictionaryStmt&>(::pg_query::_AlterTSDictionaryStmt_default_instance_);
}
inline const ::pg_query::AlterTSDictionaryStmt& Node::alter_tsdictionary_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_tsdictionary_stmt)
  return _internal_alter_tsdictionary_stmt();
}
inline ::pg_query::AlterTSDictionaryStmt* Node::unsafe_arena_release_alter_tsdictionary_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_tsdictionary_stmt)
  if (_internal_has_alter_tsdictionary_stmt()) {
    clear_has_node();
    ::pg_query::AlterTSDictionaryStmt* temp = node_.alter_tsdictionary_stmt_;
    node_.alter_tsdictionary_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_tsdictionary_stmt(::pg_query::AlterTSDictionaryStmt* alter_tsdictionary_stmt) {
  clear_node();
  if (alter_tsdictionary_stmt) {
    set_has_alter_tsdictionary_stmt();
    node_.alter_tsdictionary_stmt_ = alter_tsdictionary_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_tsdictionary_stmt)
}
inline ::pg_query::AlterTSDictionaryStmt* Node::_internal_mutable_alter_tsdictionary_stmt() {
  if (!_internal_has_alter_tsdictionary_stmt()) {
    clear_node();
    set_has_alter_tsdictionary_stmt();
    node_.alter_tsdictionary_stmt_ = CreateMaybeMessage< ::pg_query::AlterTSDictionaryStmt >(GetArena());
  }
  return node_.alter_tsdictionary_stmt_;
}
inline ::pg_query::AlterTSDictionaryStmt* Node::mutable_alter_tsdictionary_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_tsdictionary_stmt)
  return _internal_mutable_alter_tsdictionary_stmt();
}

// .pg_query.AlterTSConfigurationStmt alter_tsconfiguration_stmt = 133 [json_name = "AlterTSConfigurationStmt"];
inline bool Node::_internal_has_alter_tsconfiguration_stmt() const {
  return node_case() == kAlterTsconfigurationStmt;
}
inline bool Node::has_alter_tsconfiguration_stmt() const {
  return _internal_has_alter_tsconfiguration_stmt();
}
inline void Node::set_has_alter_tsconfiguration_stmt() {
  _oneof_case_[0] = kAlterTsconfigurationStmt;
}
inline void Node::clear_alter_tsconfiguration_stmt() {
  if (_internal_has_alter_tsconfiguration_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_tsconfiguration_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterTSConfigurationStmt* Node::release_alter_tsconfiguration_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_tsconfiguration_stmt)
  if (_internal_has_alter_tsconfiguration_stmt()) {
    clear_has_node();
      ::pg_query::AlterTSConfigurationStmt* temp = node_.alter_tsconfiguration_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_tsconfiguration_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterTSConfigurationStmt& Node::_internal_alter_tsconfiguration_stmt() const {
  return _internal_has_alter_tsconfiguration_stmt()
      ? *node_.alter_tsconfiguration_stmt_
      : reinterpret_cast< ::pg_query::AlterTSConfigurationStmt&>(::pg_query::_AlterTSConfigurationStmt_default_instance_);
}
inline const ::pg_query::AlterTSConfigurationStmt& Node::alter_tsconfiguration_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_tsconfiguration_stmt)
  return _internal_alter_tsconfiguration_stmt();
}
inline ::pg_query::AlterTSConfigurationStmt* Node::unsafe_arena_release_alter_tsconfiguration_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_tsconfiguration_stmt)
  if (_internal_has_alter_tsconfiguration_stmt()) {
    clear_has_node();
    ::pg_query::AlterTSConfigurationStmt* temp = node_.alter_tsconfiguration_stmt_;
    node_.alter_tsconfiguration_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_tsconfiguration_stmt(::pg_query::AlterTSConfigurationStmt* alter_tsconfiguration_stmt) {
  clear_node();
  if (alter_tsconfiguration_stmt) {
    set_has_alter_tsconfiguration_stmt();
    node_.alter_tsconfiguration_stmt_ = alter_tsconfiguration_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_tsconfiguration_stmt)
}
inline ::pg_query::AlterTSConfigurationStmt* Node::_internal_mutable_alter_tsconfiguration_stmt() {
  if (!_internal_has_alter_tsconfiguration_stmt()) {
    clear_node();
    set_has_alter_tsconfiguration_stmt();
    node_.alter_tsconfiguration_stmt_ = CreateMaybeMessage< ::pg_query::AlterTSConfigurationStmt >(GetArena());
  }
  return node_.alter_tsconfiguration_stmt_;
}
inline ::pg_query::AlterTSConfigurationStmt* Node::mutable_alter_tsconfiguration_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_tsconfiguration_stmt)
  return _internal_mutable_alter_tsconfiguration_stmt();
}

// .pg_query.CreateFdwStmt create_fdw_stmt = 134 [json_name = "CreateFdwStmt"];
inline bool Node::_internal_has_create_fdw_stmt() const {
  return node_case() == kCreateFdwStmt;
}
inline bool Node::has_create_fdw_stmt() const {
  return _internal_has_create_fdw_stmt();
}
inline void Node::set_has_create_fdw_stmt() {
  _oneof_case_[0] = kCreateFdwStmt;
}
inline void Node::clear_create_fdw_stmt() {
  if (_internal_has_create_fdw_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_fdw_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateFdwStmt* Node::release_create_fdw_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_fdw_stmt)
  if (_internal_has_create_fdw_stmt()) {
    clear_has_node();
      ::pg_query::CreateFdwStmt* temp = node_.create_fdw_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_fdw_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateFdwStmt& Node::_internal_create_fdw_stmt() const {
  return _internal_has_create_fdw_stmt()
      ? *node_.create_fdw_stmt_
      : reinterpret_cast< ::pg_query::CreateFdwStmt&>(::pg_query::_CreateFdwStmt_default_instance_);
}
inline const ::pg_query::CreateFdwStmt& Node::create_fdw_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_fdw_stmt)
  return _internal_create_fdw_stmt();
}
inline ::pg_query::CreateFdwStmt* Node::unsafe_arena_release_create_fdw_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_fdw_stmt)
  if (_internal_has_create_fdw_stmt()) {
    clear_has_node();
    ::pg_query::CreateFdwStmt* temp = node_.create_fdw_stmt_;
    node_.create_fdw_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_fdw_stmt(::pg_query::CreateFdwStmt* create_fdw_stmt) {
  clear_node();
  if (create_fdw_stmt) {
    set_has_create_fdw_stmt();
    node_.create_fdw_stmt_ = create_fdw_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_fdw_stmt)
}
inline ::pg_query::CreateFdwStmt* Node::_internal_mutable_create_fdw_stmt() {
  if (!_internal_has_create_fdw_stmt()) {
    clear_node();
    set_has_create_fdw_stmt();
    node_.create_fdw_stmt_ = CreateMaybeMessage< ::pg_query::CreateFdwStmt >(GetArena());
  }
  return node_.create_fdw_stmt_;
}
inline ::pg_query::CreateFdwStmt* Node::mutable_create_fdw_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_fdw_stmt)
  return _internal_mutable_create_fdw_stmt();
}

// .pg_query.AlterFdwStmt alter_fdw_stmt = 135 [json_name = "AlterFdwStmt"];
inline bool Node::_internal_has_alter_fdw_stmt() const {
  return node_case() == kAlterFdwStmt;
}
inline bool Node::has_alter_fdw_stmt() const {
  return _internal_has_alter_fdw_stmt();
}
inline void Node::set_has_alter_fdw_stmt() {
  _oneof_case_[0] = kAlterFdwStmt;
}
inline void Node::clear_alter_fdw_stmt() {
  if (_internal_has_alter_fdw_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_fdw_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterFdwStmt* Node::release_alter_fdw_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_fdw_stmt)
  if (_internal_has_alter_fdw_stmt()) {
    clear_has_node();
      ::pg_query::AlterFdwStmt* temp = node_.alter_fdw_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_fdw_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterFdwStmt& Node::_internal_alter_fdw_stmt() const {
  return _internal_has_alter_fdw_stmt()
      ? *node_.alter_fdw_stmt_
      : reinterpret_cast< ::pg_query::AlterFdwStmt&>(::pg_query::_AlterFdwStmt_default_instance_);
}
inline const ::pg_query::AlterFdwStmt& Node::alter_fdw_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_fdw_stmt)
  return _internal_alter_fdw_stmt();
}
inline ::pg_query::AlterFdwStmt* Node::unsafe_arena_release_alter_fdw_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_fdw_stmt)
  if (_internal_has_alter_fdw_stmt()) {
    clear_has_node();
    ::pg_query::AlterFdwStmt* temp = node_.alter_fdw_stmt_;
    node_.alter_fdw_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_fdw_stmt(::pg_query::AlterFdwStmt* alter_fdw_stmt) {
  clear_node();
  if (alter_fdw_stmt) {
    set_has_alter_fdw_stmt();
    node_.alter_fdw_stmt_ = alter_fdw_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_fdw_stmt)
}
inline ::pg_query::AlterFdwStmt* Node::_internal_mutable_alter_fdw_stmt() {
  if (!_internal_has_alter_fdw_stmt()) {
    clear_node();
    set_has_alter_fdw_stmt();
    node_.alter_fdw_stmt_ = CreateMaybeMessage< ::pg_query::AlterFdwStmt >(GetArena());
  }
  return node_.alter_fdw_stmt_;
}
inline ::pg_query::AlterFdwStmt* Node::mutable_alter_fdw_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_fdw_stmt)
  return _internal_mutable_alter_fdw_stmt();
}

// .pg_query.CreateForeignServerStmt create_foreign_server_stmt = 136 [json_name = "CreateForeignServerStmt"];
inline bool Node::_internal_has_create_foreign_server_stmt() const {
  return node_case() == kCreateForeignServerStmt;
}
inline bool Node::has_create_foreign_server_stmt() const {
  return _internal_has_create_foreign_server_stmt();
}
inline void Node::set_has_create_foreign_server_stmt() {
  _oneof_case_[0] = kCreateForeignServerStmt;
}
inline void Node::clear_create_foreign_server_stmt() {
  if (_internal_has_create_foreign_server_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_foreign_server_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateForeignServerStmt* Node::release_create_foreign_server_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_foreign_server_stmt)
  if (_internal_has_create_foreign_server_stmt()) {
    clear_has_node();
      ::pg_query::CreateForeignServerStmt* temp = node_.create_foreign_server_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_foreign_server_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateForeignServerStmt& Node::_internal_create_foreign_server_stmt() const {
  return _internal_has_create_foreign_server_stmt()
      ? *node_.create_foreign_server_stmt_
      : reinterpret_cast< ::pg_query::CreateForeignServerStmt&>(::pg_query::_CreateForeignServerStmt_default_instance_);
}
inline const ::pg_query::CreateForeignServerStmt& Node::create_foreign_server_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_foreign_server_stmt)
  return _internal_create_foreign_server_stmt();
}
inline ::pg_query::CreateForeignServerStmt* Node::unsafe_arena_release_create_foreign_server_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_foreign_server_stmt)
  if (_internal_has_create_foreign_server_stmt()) {
    clear_has_node();
    ::pg_query::CreateForeignServerStmt* temp = node_.create_foreign_server_stmt_;
    node_.create_foreign_server_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_foreign_server_stmt(::pg_query::CreateForeignServerStmt* create_foreign_server_stmt) {
  clear_node();
  if (create_foreign_server_stmt) {
    set_has_create_foreign_server_stmt();
    node_.create_foreign_server_stmt_ = create_foreign_server_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_foreign_server_stmt)
}
inline ::pg_query::CreateForeignServerStmt* Node::_internal_mutable_create_foreign_server_stmt() {
  if (!_internal_has_create_foreign_server_stmt()) {
    clear_node();
    set_has_create_foreign_server_stmt();
    node_.create_foreign_server_stmt_ = CreateMaybeMessage< ::pg_query::CreateForeignServerStmt >(GetArena());
  }
  return node_.create_foreign_server_stmt_;
}
inline ::pg_query::CreateForeignServerStmt* Node::mutable_create_foreign_server_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_foreign_server_stmt)
  return _internal_mutable_create_foreign_server_stmt();
}

// .pg_query.AlterForeignServerStmt alter_foreign_server_stmt = 137 [json_name = "AlterForeignServerStmt"];
inline bool Node::_internal_has_alter_foreign_server_stmt() const {
  return node_case() == kAlterForeignServerStmt;
}
inline bool Node::has_alter_foreign_server_stmt() const {
  return _internal_has_alter_foreign_server_stmt();
}
inline void Node::set_has_alter_foreign_server_stmt() {
  _oneof_case_[0] = kAlterForeignServerStmt;
}
inline void Node::clear_alter_foreign_server_stmt() {
  if (_internal_has_alter_foreign_server_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_foreign_server_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterForeignServerStmt* Node::release_alter_foreign_server_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_foreign_server_stmt)
  if (_internal_has_alter_foreign_server_stmt()) {
    clear_has_node();
      ::pg_query::AlterForeignServerStmt* temp = node_.alter_foreign_server_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_foreign_server_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterForeignServerStmt& Node::_internal_alter_foreign_server_stmt() const {
  return _internal_has_alter_foreign_server_stmt()
      ? *node_.alter_foreign_server_stmt_
      : reinterpret_cast< ::pg_query::AlterForeignServerStmt&>(::pg_query::_AlterForeignServerStmt_default_instance_);
}
inline const ::pg_query::AlterForeignServerStmt& Node::alter_foreign_server_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_foreign_server_stmt)
  return _internal_alter_foreign_server_stmt();
}
inline ::pg_query::AlterForeignServerStmt* Node::unsafe_arena_release_alter_foreign_server_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_foreign_server_stmt)
  if (_internal_has_alter_foreign_server_stmt()) {
    clear_has_node();
    ::pg_query::AlterForeignServerStmt* temp = node_.alter_foreign_server_stmt_;
    node_.alter_foreign_server_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_foreign_server_stmt(::pg_query::AlterForeignServerStmt* alter_foreign_server_stmt) {
  clear_node();
  if (alter_foreign_server_stmt) {
    set_has_alter_foreign_server_stmt();
    node_.alter_foreign_server_stmt_ = alter_foreign_server_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_foreign_server_stmt)
}
inline ::pg_query::AlterForeignServerStmt* Node::_internal_mutable_alter_foreign_server_stmt() {
  if (!_internal_has_alter_foreign_server_stmt()) {
    clear_node();
    set_has_alter_foreign_server_stmt();
    node_.alter_foreign_server_stmt_ = CreateMaybeMessage< ::pg_query::AlterForeignServerStmt >(GetArena());
  }
  return node_.alter_foreign_server_stmt_;
}
inline ::pg_query::AlterForeignServerStmt* Node::mutable_alter_foreign_server_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_foreign_server_stmt)
  return _internal_mutable_alter_foreign_server_stmt();
}

// .pg_query.CreateUserMappingStmt create_user_mapping_stmt = 138 [json_name = "CreateUserMappingStmt"];
inline bool Node::_internal_has_create_user_mapping_stmt() const {
  return node_case() == kCreateUserMappingStmt;
}
inline bool Node::has_create_user_mapping_stmt() const {
  return _internal_has_create_user_mapping_stmt();
}
inline void Node::set_has_create_user_mapping_stmt() {
  _oneof_case_[0] = kCreateUserMappingStmt;
}
inline void Node::clear_create_user_mapping_stmt() {
  if (_internal_has_create_user_mapping_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_user_mapping_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateUserMappingStmt* Node::release_create_user_mapping_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_user_mapping_stmt)
  if (_internal_has_create_user_mapping_stmt()) {
    clear_has_node();
      ::pg_query::CreateUserMappingStmt* temp = node_.create_user_mapping_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_user_mapping_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateUserMappingStmt& Node::_internal_create_user_mapping_stmt() const {
  return _internal_has_create_user_mapping_stmt()
      ? *node_.create_user_mapping_stmt_
      : reinterpret_cast< ::pg_query::CreateUserMappingStmt&>(::pg_query::_CreateUserMappingStmt_default_instance_);
}
inline const ::pg_query::CreateUserMappingStmt& Node::create_user_mapping_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_user_mapping_stmt)
  return _internal_create_user_mapping_stmt();
}
inline ::pg_query::CreateUserMappingStmt* Node::unsafe_arena_release_create_user_mapping_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_user_mapping_stmt)
  if (_internal_has_create_user_mapping_stmt()) {
    clear_has_node();
    ::pg_query::CreateUserMappingStmt* temp = node_.create_user_mapping_stmt_;
    node_.create_user_mapping_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_user_mapping_stmt(::pg_query::CreateUserMappingStmt* create_user_mapping_stmt) {
  clear_node();
  if (create_user_mapping_stmt) {
    set_has_create_user_mapping_stmt();
    node_.create_user_mapping_stmt_ = create_user_mapping_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_user_mapping_stmt)
}
inline ::pg_query::CreateUserMappingStmt* Node::_internal_mutable_create_user_mapping_stmt() {
  if (!_internal_has_create_user_mapping_stmt()) {
    clear_node();
    set_has_create_user_mapping_stmt();
    node_.create_user_mapping_stmt_ = CreateMaybeMessage< ::pg_query::CreateUserMappingStmt >(GetArena());
  }
  return node_.create_user_mapping_stmt_;
}
inline ::pg_query::CreateUserMappingStmt* Node::mutable_create_user_mapping_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_user_mapping_stmt)
  return _internal_mutable_create_user_mapping_stmt();
}

// .pg_query.AlterUserMappingStmt alter_user_mapping_stmt = 139 [json_name = "AlterUserMappingStmt"];
inline bool Node::_internal_has_alter_user_mapping_stmt() const {
  return node_case() == kAlterUserMappingStmt;
}
inline bool Node::has_alter_user_mapping_stmt() const {
  return _internal_has_alter_user_mapping_stmt();
}
inline void Node::set_has_alter_user_mapping_stmt() {
  _oneof_case_[0] = kAlterUserMappingStmt;
}
inline void Node::clear_alter_user_mapping_stmt() {
  if (_internal_has_alter_user_mapping_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_user_mapping_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterUserMappingStmt* Node::release_alter_user_mapping_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_user_mapping_stmt)
  if (_internal_has_alter_user_mapping_stmt()) {
    clear_has_node();
      ::pg_query::AlterUserMappingStmt* temp = node_.alter_user_mapping_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_user_mapping_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterUserMappingStmt& Node::_internal_alter_user_mapping_stmt() const {
  return _internal_has_alter_user_mapping_stmt()
      ? *node_.alter_user_mapping_stmt_
      : reinterpret_cast< ::pg_query::AlterUserMappingStmt&>(::pg_query::_AlterUserMappingStmt_default_instance_);
}
inline const ::pg_query::AlterUserMappingStmt& Node::alter_user_mapping_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_user_mapping_stmt)
  return _internal_alter_user_mapping_stmt();
}
inline ::pg_query::AlterUserMappingStmt* Node::unsafe_arena_release_alter_user_mapping_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_user_mapping_stmt)
  if (_internal_has_alter_user_mapping_stmt()) {
    clear_has_node();
    ::pg_query::AlterUserMappingStmt* temp = node_.alter_user_mapping_stmt_;
    node_.alter_user_mapping_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_user_mapping_stmt(::pg_query::AlterUserMappingStmt* alter_user_mapping_stmt) {
  clear_node();
  if (alter_user_mapping_stmt) {
    set_has_alter_user_mapping_stmt();
    node_.alter_user_mapping_stmt_ = alter_user_mapping_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_user_mapping_stmt)
}
inline ::pg_query::AlterUserMappingStmt* Node::_internal_mutable_alter_user_mapping_stmt() {
  if (!_internal_has_alter_user_mapping_stmt()) {
    clear_node();
    set_has_alter_user_mapping_stmt();
    node_.alter_user_mapping_stmt_ = CreateMaybeMessage< ::pg_query::AlterUserMappingStmt >(GetArena());
  }
  return node_.alter_user_mapping_stmt_;
}
inline ::pg_query::AlterUserMappingStmt* Node::mutable_alter_user_mapping_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_user_mapping_stmt)
  return _internal_mutable_alter_user_mapping_stmt();
}

// .pg_query.DropUserMappingStmt drop_user_mapping_stmt = 140 [json_name = "DropUserMappingStmt"];
inline bool Node::_internal_has_drop_user_mapping_stmt() const {
  return node_case() == kDropUserMappingStmt;
}
inline bool Node::has_drop_user_mapping_stmt() const {
  return _internal_has_drop_user_mapping_stmt();
}
inline void Node::set_has_drop_user_mapping_stmt() {
  _oneof_case_[0] = kDropUserMappingStmt;
}
inline void Node::clear_drop_user_mapping_stmt() {
  if (_internal_has_drop_user_mapping_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.drop_user_mapping_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DropUserMappingStmt* Node::release_drop_user_mapping_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.drop_user_mapping_stmt)
  if (_internal_has_drop_user_mapping_stmt()) {
    clear_has_node();
      ::pg_query::DropUserMappingStmt* temp = node_.drop_user_mapping_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.drop_user_mapping_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropUserMappingStmt& Node::_internal_drop_user_mapping_stmt() const {
  return _internal_has_drop_user_mapping_stmt()
      ? *node_.drop_user_mapping_stmt_
      : reinterpret_cast< ::pg_query::DropUserMappingStmt&>(::pg_query::_DropUserMappingStmt_default_instance_);
}
inline const ::pg_query::DropUserMappingStmt& Node::drop_user_mapping_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.drop_user_mapping_stmt)
  return _internal_drop_user_mapping_stmt();
}
inline ::pg_query::DropUserMappingStmt* Node::unsafe_arena_release_drop_user_mapping_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.drop_user_mapping_stmt)
  if (_internal_has_drop_user_mapping_stmt()) {
    clear_has_node();
    ::pg_query::DropUserMappingStmt* temp = node_.drop_user_mapping_stmt_;
    node_.drop_user_mapping_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_drop_user_mapping_stmt(::pg_query::DropUserMappingStmt* drop_user_mapping_stmt) {
  clear_node();
  if (drop_user_mapping_stmt) {
    set_has_drop_user_mapping_stmt();
    node_.drop_user_mapping_stmt_ = drop_user_mapping_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.drop_user_mapping_stmt)
}
inline ::pg_query::DropUserMappingStmt* Node::_internal_mutable_drop_user_mapping_stmt() {
  if (!_internal_has_drop_user_mapping_stmt()) {
    clear_node();
    set_has_drop_user_mapping_stmt();
    node_.drop_user_mapping_stmt_ = CreateMaybeMessage< ::pg_query::DropUserMappingStmt >(GetArena());
  }
  return node_.drop_user_mapping_stmt_;
}
inline ::pg_query::DropUserMappingStmt* Node::mutable_drop_user_mapping_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_user_mapping_stmt)
  return _internal_mutable_drop_user_mapping_stmt();
}

// .pg_query.AlterTableSpaceOptionsStmt alter_table_space_options_stmt = 141 [json_name = "AlterTableSpaceOptionsStmt"];
inline bool Node::_internal_has_alter_table_space_options_stmt() const {
  return node_case() == kAlterTableSpaceOptionsStmt;
}
inline bool Node::has_alter_table_space_options_stmt() const {
  return _internal_has_alter_table_space_options_stmt();
}
inline void Node::set_has_alter_table_space_options_stmt() {
  _oneof_case_[0] = kAlterTableSpaceOptionsStmt;
}
inline void Node::clear_alter_table_space_options_stmt() {
  if (_internal_has_alter_table_space_options_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_table_space_options_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterTableSpaceOptionsStmt* Node::release_alter_table_space_options_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_table_space_options_stmt)
  if (_internal_has_alter_table_space_options_stmt()) {
    clear_has_node();
      ::pg_query::AlterTableSpaceOptionsStmt* temp = node_.alter_table_space_options_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_table_space_options_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterTableSpaceOptionsStmt& Node::_internal_alter_table_space_options_stmt() const {
  return _internal_has_alter_table_space_options_stmt()
      ? *node_.alter_table_space_options_stmt_
      : reinterpret_cast< ::pg_query::AlterTableSpaceOptionsStmt&>(::pg_query::_AlterTableSpaceOptionsStmt_default_instance_);
}
inline const ::pg_query::AlterTableSpaceOptionsStmt& Node::alter_table_space_options_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_table_space_options_stmt)
  return _internal_alter_table_space_options_stmt();
}
inline ::pg_query::AlterTableSpaceOptionsStmt* Node::unsafe_arena_release_alter_table_space_options_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_table_space_options_stmt)
  if (_internal_has_alter_table_space_options_stmt()) {
    clear_has_node();
    ::pg_query::AlterTableSpaceOptionsStmt* temp = node_.alter_table_space_options_stmt_;
    node_.alter_table_space_options_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_table_space_options_stmt(::pg_query::AlterTableSpaceOptionsStmt* alter_table_space_options_stmt) {
  clear_node();
  if (alter_table_space_options_stmt) {
    set_has_alter_table_space_options_stmt();
    node_.alter_table_space_options_stmt_ = alter_table_space_options_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_table_space_options_stmt)
}
inline ::pg_query::AlterTableSpaceOptionsStmt* Node::_internal_mutable_alter_table_space_options_stmt() {
  if (!_internal_has_alter_table_space_options_stmt()) {
    clear_node();
    set_has_alter_table_space_options_stmt();
    node_.alter_table_space_options_stmt_ = CreateMaybeMessage< ::pg_query::AlterTableSpaceOptionsStmt >(GetArena());
  }
  return node_.alter_table_space_options_stmt_;
}
inline ::pg_query::AlterTableSpaceOptionsStmt* Node::mutable_alter_table_space_options_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_table_space_options_stmt)
  return _internal_mutable_alter_table_space_options_stmt();
}

// .pg_query.AlterTableMoveAllStmt alter_table_move_all_stmt = 142 [json_name = "AlterTableMoveAllStmt"];
inline bool Node::_internal_has_alter_table_move_all_stmt() const {
  return node_case() == kAlterTableMoveAllStmt;
}
inline bool Node::has_alter_table_move_all_stmt() const {
  return _internal_has_alter_table_move_all_stmt();
}
inline void Node::set_has_alter_table_move_all_stmt() {
  _oneof_case_[0] = kAlterTableMoveAllStmt;
}
inline void Node::clear_alter_table_move_all_stmt() {
  if (_internal_has_alter_table_move_all_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_table_move_all_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterTableMoveAllStmt* Node::release_alter_table_move_all_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_table_move_all_stmt)
  if (_internal_has_alter_table_move_all_stmt()) {
    clear_has_node();
      ::pg_query::AlterTableMoveAllStmt* temp = node_.alter_table_move_all_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_table_move_all_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterTableMoveAllStmt& Node::_internal_alter_table_move_all_stmt() const {
  return _internal_has_alter_table_move_all_stmt()
      ? *node_.alter_table_move_all_stmt_
      : reinterpret_cast< ::pg_query::AlterTableMoveAllStmt&>(::pg_query::_AlterTableMoveAllStmt_default_instance_);
}
inline const ::pg_query::AlterTableMoveAllStmt& Node::alter_table_move_all_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_table_move_all_stmt)
  return _internal_alter_table_move_all_stmt();
}
inline ::pg_query::AlterTableMoveAllStmt* Node::unsafe_arena_release_alter_table_move_all_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_table_move_all_stmt)
  if (_internal_has_alter_table_move_all_stmt()) {
    clear_has_node();
    ::pg_query::AlterTableMoveAllStmt* temp = node_.alter_table_move_all_stmt_;
    node_.alter_table_move_all_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_table_move_all_stmt(::pg_query::AlterTableMoveAllStmt* alter_table_move_all_stmt) {
  clear_node();
  if (alter_table_move_all_stmt) {
    set_has_alter_table_move_all_stmt();
    node_.alter_table_move_all_stmt_ = alter_table_move_all_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_table_move_all_stmt)
}
inline ::pg_query::AlterTableMoveAllStmt* Node::_internal_mutable_alter_table_move_all_stmt() {
  if (!_internal_has_alter_table_move_all_stmt()) {
    clear_node();
    set_has_alter_table_move_all_stmt();
    node_.alter_table_move_all_stmt_ = CreateMaybeMessage< ::pg_query::AlterTableMoveAllStmt >(GetArena());
  }
  return node_.alter_table_move_all_stmt_;
}
inline ::pg_query::AlterTableMoveAllStmt* Node::mutable_alter_table_move_all_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_table_move_all_stmt)
  return _internal_mutable_alter_table_move_all_stmt();
}

// .pg_query.SecLabelStmt sec_label_stmt = 143 [json_name = "SecLabelStmt"];
inline bool Node::_internal_has_sec_label_stmt() const {
  return node_case() == kSecLabelStmt;
}
inline bool Node::has_sec_label_stmt() const {
  return _internal_has_sec_label_stmt();
}
inline void Node::set_has_sec_label_stmt() {
  _oneof_case_[0] = kSecLabelStmt;
}
inline void Node::clear_sec_label_stmt() {
  if (_internal_has_sec_label_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.sec_label_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::SecLabelStmt* Node::release_sec_label_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.sec_label_stmt)
  if (_internal_has_sec_label_stmt()) {
    clear_has_node();
      ::pg_query::SecLabelStmt* temp = node_.sec_label_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.sec_label_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SecLabelStmt& Node::_internal_sec_label_stmt() const {
  return _internal_has_sec_label_stmt()
      ? *node_.sec_label_stmt_
      : reinterpret_cast< ::pg_query::SecLabelStmt&>(::pg_query::_SecLabelStmt_default_instance_);
}
inline const ::pg_query::SecLabelStmt& Node::sec_label_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.sec_label_stmt)
  return _internal_sec_label_stmt();
}
inline ::pg_query::SecLabelStmt* Node::unsafe_arena_release_sec_label_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.sec_label_stmt)
  if (_internal_has_sec_label_stmt()) {
    clear_has_node();
    ::pg_query::SecLabelStmt* temp = node_.sec_label_stmt_;
    node_.sec_label_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_sec_label_stmt(::pg_query::SecLabelStmt* sec_label_stmt) {
  clear_node();
  if (sec_label_stmt) {
    set_has_sec_label_stmt();
    node_.sec_label_stmt_ = sec_label_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sec_label_stmt)
}
inline ::pg_query::SecLabelStmt* Node::_internal_mutable_sec_label_stmt() {
  if (!_internal_has_sec_label_stmt()) {
    clear_node();
    set_has_sec_label_stmt();
    node_.sec_label_stmt_ = CreateMaybeMessage< ::pg_query::SecLabelStmt >(GetArena());
  }
  return node_.sec_label_stmt_;
}
inline ::pg_query::SecLabelStmt* Node::mutable_sec_label_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.sec_label_stmt)
  return _internal_mutable_sec_label_stmt();
}

// .pg_query.CreateForeignTableStmt create_foreign_table_stmt = 144 [json_name = "CreateForeignTableStmt"];
inline bool Node::_internal_has_create_foreign_table_stmt() const {
  return node_case() == kCreateForeignTableStmt;
}
inline bool Node::has_create_foreign_table_stmt() const {
  return _internal_has_create_foreign_table_stmt();
}
inline void Node::set_has_create_foreign_table_stmt() {
  _oneof_case_[0] = kCreateForeignTableStmt;
}
inline void Node::clear_create_foreign_table_stmt() {
  if (_internal_has_create_foreign_table_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_foreign_table_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateForeignTableStmt* Node::release_create_foreign_table_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_foreign_table_stmt)
  if (_internal_has_create_foreign_table_stmt()) {
    clear_has_node();
      ::pg_query::CreateForeignTableStmt* temp = node_.create_foreign_table_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_foreign_table_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateForeignTableStmt& Node::_internal_create_foreign_table_stmt() const {
  return _internal_has_create_foreign_table_stmt()
      ? *node_.create_foreign_table_stmt_
      : reinterpret_cast< ::pg_query::CreateForeignTableStmt&>(::pg_query::_CreateForeignTableStmt_default_instance_);
}
inline const ::pg_query::CreateForeignTableStmt& Node::create_foreign_table_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_foreign_table_stmt)
  return _internal_create_foreign_table_stmt();
}
inline ::pg_query::CreateForeignTableStmt* Node::unsafe_arena_release_create_foreign_table_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_foreign_table_stmt)
  if (_internal_has_create_foreign_table_stmt()) {
    clear_has_node();
    ::pg_query::CreateForeignTableStmt* temp = node_.create_foreign_table_stmt_;
    node_.create_foreign_table_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_foreign_table_stmt(::pg_query::CreateForeignTableStmt* create_foreign_table_stmt) {
  clear_node();
  if (create_foreign_table_stmt) {
    set_has_create_foreign_table_stmt();
    node_.create_foreign_table_stmt_ = create_foreign_table_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_foreign_table_stmt)
}
inline ::pg_query::CreateForeignTableStmt* Node::_internal_mutable_create_foreign_table_stmt() {
  if (!_internal_has_create_foreign_table_stmt()) {
    clear_node();
    set_has_create_foreign_table_stmt();
    node_.create_foreign_table_stmt_ = CreateMaybeMessage< ::pg_query::CreateForeignTableStmt >(GetArena());
  }
  return node_.create_foreign_table_stmt_;
}
inline ::pg_query::CreateForeignTableStmt* Node::mutable_create_foreign_table_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_foreign_table_stmt)
  return _internal_mutable_create_foreign_table_stmt();
}

// .pg_query.ImportForeignSchemaStmt import_foreign_schema_stmt = 145 [json_name = "ImportForeignSchemaStmt"];
inline bool Node::_internal_has_import_foreign_schema_stmt() const {
  return node_case() == kImportForeignSchemaStmt;
}
inline bool Node::has_import_foreign_schema_stmt() const {
  return _internal_has_import_foreign_schema_stmt();
}
inline void Node::set_has_import_foreign_schema_stmt() {
  _oneof_case_[0] = kImportForeignSchemaStmt;
}
inline void Node::clear_import_foreign_schema_stmt() {
  if (_internal_has_import_foreign_schema_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.import_foreign_schema_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ImportForeignSchemaStmt* Node::release_import_foreign_schema_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.import_foreign_schema_stmt)
  if (_internal_has_import_foreign_schema_stmt()) {
    clear_has_node();
      ::pg_query::ImportForeignSchemaStmt* temp = node_.import_foreign_schema_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.import_foreign_schema_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ImportForeignSchemaStmt& Node::_internal_import_foreign_schema_stmt() const {
  return _internal_has_import_foreign_schema_stmt()
      ? *node_.import_foreign_schema_stmt_
      : reinterpret_cast< ::pg_query::ImportForeignSchemaStmt&>(::pg_query::_ImportForeignSchemaStmt_default_instance_);
}
inline const ::pg_query::ImportForeignSchemaStmt& Node::import_foreign_schema_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.import_foreign_schema_stmt)
  return _internal_import_foreign_schema_stmt();
}
inline ::pg_query::ImportForeignSchemaStmt* Node::unsafe_arena_release_import_foreign_schema_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.import_foreign_schema_stmt)
  if (_internal_has_import_foreign_schema_stmt()) {
    clear_has_node();
    ::pg_query::ImportForeignSchemaStmt* temp = node_.import_foreign_schema_stmt_;
    node_.import_foreign_schema_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_import_foreign_schema_stmt(::pg_query::ImportForeignSchemaStmt* import_foreign_schema_stmt) {
  clear_node();
  if (import_foreign_schema_stmt) {
    set_has_import_foreign_schema_stmt();
    node_.import_foreign_schema_stmt_ = import_foreign_schema_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.import_foreign_schema_stmt)
}
inline ::pg_query::ImportForeignSchemaStmt* Node::_internal_mutable_import_foreign_schema_stmt() {
  if (!_internal_has_import_foreign_schema_stmt()) {
    clear_node();
    set_has_import_foreign_schema_stmt();
    node_.import_foreign_schema_stmt_ = CreateMaybeMessage< ::pg_query::ImportForeignSchemaStmt >(GetArena());
  }
  return node_.import_foreign_schema_stmt_;
}
inline ::pg_query::ImportForeignSchemaStmt* Node::mutable_import_foreign_schema_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.import_foreign_schema_stmt)
  return _internal_mutable_import_foreign_schema_stmt();
}

// .pg_query.CreateExtensionStmt create_extension_stmt = 146 [json_name = "CreateExtensionStmt"];
inline bool Node::_internal_has_create_extension_stmt() const {
  return node_case() == kCreateExtensionStmt;
}
inline bool Node::has_create_extension_stmt() const {
  return _internal_has_create_extension_stmt();
}
inline void Node::set_has_create_extension_stmt() {
  _oneof_case_[0] = kCreateExtensionStmt;
}
inline void Node::clear_create_extension_stmt() {
  if (_internal_has_create_extension_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_extension_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateExtensionStmt* Node::release_create_extension_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_extension_stmt)
  if (_internal_has_create_extension_stmt()) {
    clear_has_node();
      ::pg_query::CreateExtensionStmt* temp = node_.create_extension_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_extension_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateExtensionStmt& Node::_internal_create_extension_stmt() const {
  return _internal_has_create_extension_stmt()
      ? *node_.create_extension_stmt_
      : reinterpret_cast< ::pg_query::CreateExtensionStmt&>(::pg_query::_CreateExtensionStmt_default_instance_);
}
inline const ::pg_query::CreateExtensionStmt& Node::create_extension_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_extension_stmt)
  return _internal_create_extension_stmt();
}
inline ::pg_query::CreateExtensionStmt* Node::unsafe_arena_release_create_extension_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_extension_stmt)
  if (_internal_has_create_extension_stmt()) {
    clear_has_node();
    ::pg_query::CreateExtensionStmt* temp = node_.create_extension_stmt_;
    node_.create_extension_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_extension_stmt(::pg_query::CreateExtensionStmt* create_extension_stmt) {
  clear_node();
  if (create_extension_stmt) {
    set_has_create_extension_stmt();
    node_.create_extension_stmt_ = create_extension_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_extension_stmt)
}
inline ::pg_query::CreateExtensionStmt* Node::_internal_mutable_create_extension_stmt() {
  if (!_internal_has_create_extension_stmt()) {
    clear_node();
    set_has_create_extension_stmt();
    node_.create_extension_stmt_ = CreateMaybeMessage< ::pg_query::CreateExtensionStmt >(GetArena());
  }
  return node_.create_extension_stmt_;
}
inline ::pg_query::CreateExtensionStmt* Node::mutable_create_extension_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_extension_stmt)
  return _internal_mutable_create_extension_stmt();
}

// .pg_query.AlterExtensionStmt alter_extension_stmt = 147 [json_name = "AlterExtensionStmt"];
inline bool Node::_internal_has_alter_extension_stmt() const {
  return node_case() == kAlterExtensionStmt;
}
inline bool Node::has_alter_extension_stmt() const {
  return _internal_has_alter_extension_stmt();
}
inline void Node::set_has_alter_extension_stmt() {
  _oneof_case_[0] = kAlterExtensionStmt;
}
inline void Node::clear_alter_extension_stmt() {
  if (_internal_has_alter_extension_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_extension_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterExtensionStmt* Node::release_alter_extension_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_extension_stmt)
  if (_internal_has_alter_extension_stmt()) {
    clear_has_node();
      ::pg_query::AlterExtensionStmt* temp = node_.alter_extension_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_extension_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterExtensionStmt& Node::_internal_alter_extension_stmt() const {
  return _internal_has_alter_extension_stmt()
      ? *node_.alter_extension_stmt_
      : reinterpret_cast< ::pg_query::AlterExtensionStmt&>(::pg_query::_AlterExtensionStmt_default_instance_);
}
inline const ::pg_query::AlterExtensionStmt& Node::alter_extension_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_extension_stmt)
  return _internal_alter_extension_stmt();
}
inline ::pg_query::AlterExtensionStmt* Node::unsafe_arena_release_alter_extension_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_extension_stmt)
  if (_internal_has_alter_extension_stmt()) {
    clear_has_node();
    ::pg_query::AlterExtensionStmt* temp = node_.alter_extension_stmt_;
    node_.alter_extension_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_extension_stmt(::pg_query::AlterExtensionStmt* alter_extension_stmt) {
  clear_node();
  if (alter_extension_stmt) {
    set_has_alter_extension_stmt();
    node_.alter_extension_stmt_ = alter_extension_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_extension_stmt)
}
inline ::pg_query::AlterExtensionStmt* Node::_internal_mutable_alter_extension_stmt() {
  if (!_internal_has_alter_extension_stmt()) {
    clear_node();
    set_has_alter_extension_stmt();
    node_.alter_extension_stmt_ = CreateMaybeMessage< ::pg_query::AlterExtensionStmt >(GetArena());
  }
  return node_.alter_extension_stmt_;
}
inline ::pg_query::AlterExtensionStmt* Node::mutable_alter_extension_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_extension_stmt)
  return _internal_mutable_alter_extension_stmt();
}

// .pg_query.AlterExtensionContentsStmt alter_extension_contents_stmt = 148 [json_name = "AlterExtensionContentsStmt"];
inline bool Node::_internal_has_alter_extension_contents_stmt() const {
  return node_case() == kAlterExtensionContentsStmt;
}
inline bool Node::has_alter_extension_contents_stmt() const {
  return _internal_has_alter_extension_contents_stmt();
}
inline void Node::set_has_alter_extension_contents_stmt() {
  _oneof_case_[0] = kAlterExtensionContentsStmt;
}
inline void Node::clear_alter_extension_contents_stmt() {
  if (_internal_has_alter_extension_contents_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_extension_contents_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterExtensionContentsStmt* Node::release_alter_extension_contents_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_extension_contents_stmt)
  if (_internal_has_alter_extension_contents_stmt()) {
    clear_has_node();
      ::pg_query::AlterExtensionContentsStmt* temp = node_.alter_extension_contents_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_extension_contents_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterExtensionContentsStmt& Node::_internal_alter_extension_contents_stmt() const {
  return _internal_has_alter_extension_contents_stmt()
      ? *node_.alter_extension_contents_stmt_
      : reinterpret_cast< ::pg_query::AlterExtensionContentsStmt&>(::pg_query::_AlterExtensionContentsStmt_default_instance_);
}
inline const ::pg_query::AlterExtensionContentsStmt& Node::alter_extension_contents_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_extension_contents_stmt)
  return _internal_alter_extension_contents_stmt();
}
inline ::pg_query::AlterExtensionContentsStmt* Node::unsafe_arena_release_alter_extension_contents_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_extension_contents_stmt)
  if (_internal_has_alter_extension_contents_stmt()) {
    clear_has_node();
    ::pg_query::AlterExtensionContentsStmt* temp = node_.alter_extension_contents_stmt_;
    node_.alter_extension_contents_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_extension_contents_stmt(::pg_query::AlterExtensionContentsStmt* alter_extension_contents_stmt) {
  clear_node();
  if (alter_extension_contents_stmt) {
    set_has_alter_extension_contents_stmt();
    node_.alter_extension_contents_stmt_ = alter_extension_contents_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_extension_contents_stmt)
}
inline ::pg_query::AlterExtensionContentsStmt* Node::_internal_mutable_alter_extension_contents_stmt() {
  if (!_internal_has_alter_extension_contents_stmt()) {
    clear_node();
    set_has_alter_extension_contents_stmt();
    node_.alter_extension_contents_stmt_ = CreateMaybeMessage< ::pg_query::AlterExtensionContentsStmt >(GetArena());
  }
  return node_.alter_extension_contents_stmt_;
}
inline ::pg_query::AlterExtensionContentsStmt* Node::mutable_alter_extension_contents_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_extension_contents_stmt)
  return _internal_mutable_alter_extension_contents_stmt();
}

// .pg_query.CreateEventTrigStmt create_event_trig_stmt = 149 [json_name = "CreateEventTrigStmt"];
inline bool Node::_internal_has_create_event_trig_stmt() const {
  return node_case() == kCreateEventTrigStmt;
}
inline bool Node::has_create_event_trig_stmt() const {
  return _internal_has_create_event_trig_stmt();
}
inline void Node::set_has_create_event_trig_stmt() {
  _oneof_case_[0] = kCreateEventTrigStmt;
}
inline void Node::clear_create_event_trig_stmt() {
  if (_internal_has_create_event_trig_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_event_trig_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateEventTrigStmt* Node::release_create_event_trig_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_event_trig_stmt)
  if (_internal_has_create_event_trig_stmt()) {
    clear_has_node();
      ::pg_query::CreateEventTrigStmt* temp = node_.create_event_trig_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_event_trig_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateEventTrigStmt& Node::_internal_create_event_trig_stmt() const {
  return _internal_has_create_event_trig_stmt()
      ? *node_.create_event_trig_stmt_
      : reinterpret_cast< ::pg_query::CreateEventTrigStmt&>(::pg_query::_CreateEventTrigStmt_default_instance_);
}
inline const ::pg_query::CreateEventTrigStmt& Node::create_event_trig_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_event_trig_stmt)
  return _internal_create_event_trig_stmt();
}
inline ::pg_query::CreateEventTrigStmt* Node::unsafe_arena_release_create_event_trig_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_event_trig_stmt)
  if (_internal_has_create_event_trig_stmt()) {
    clear_has_node();
    ::pg_query::CreateEventTrigStmt* temp = node_.create_event_trig_stmt_;
    node_.create_event_trig_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_event_trig_stmt(::pg_query::CreateEventTrigStmt* create_event_trig_stmt) {
  clear_node();
  if (create_event_trig_stmt) {
    set_has_create_event_trig_stmt();
    node_.create_event_trig_stmt_ = create_event_trig_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_event_trig_stmt)
}
inline ::pg_query::CreateEventTrigStmt* Node::_internal_mutable_create_event_trig_stmt() {
  if (!_internal_has_create_event_trig_stmt()) {
    clear_node();
    set_has_create_event_trig_stmt();
    node_.create_event_trig_stmt_ = CreateMaybeMessage< ::pg_query::CreateEventTrigStmt >(GetArena());
  }
  return node_.create_event_trig_stmt_;
}
inline ::pg_query::CreateEventTrigStmt* Node::mutable_create_event_trig_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_event_trig_stmt)
  return _internal_mutable_create_event_trig_stmt();
}

// .pg_query.AlterEventTrigStmt alter_event_trig_stmt = 150 [json_name = "AlterEventTrigStmt"];
inline bool Node::_internal_has_alter_event_trig_stmt() const {
  return node_case() == kAlterEventTrigStmt;
}
inline bool Node::has_alter_event_trig_stmt() const {
  return _internal_has_alter_event_trig_stmt();
}
inline void Node::set_has_alter_event_trig_stmt() {
  _oneof_case_[0] = kAlterEventTrigStmt;
}
inline void Node::clear_alter_event_trig_stmt() {
  if (_internal_has_alter_event_trig_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_event_trig_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterEventTrigStmt* Node::release_alter_event_trig_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_event_trig_stmt)
  if (_internal_has_alter_event_trig_stmt()) {
    clear_has_node();
      ::pg_query::AlterEventTrigStmt* temp = node_.alter_event_trig_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_event_trig_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterEventTrigStmt& Node::_internal_alter_event_trig_stmt() const {
  return _internal_has_alter_event_trig_stmt()
      ? *node_.alter_event_trig_stmt_
      : reinterpret_cast< ::pg_query::AlterEventTrigStmt&>(::pg_query::_AlterEventTrigStmt_default_instance_);
}
inline const ::pg_query::AlterEventTrigStmt& Node::alter_event_trig_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_event_trig_stmt)
  return _internal_alter_event_trig_stmt();
}
inline ::pg_query::AlterEventTrigStmt* Node::unsafe_arena_release_alter_event_trig_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_event_trig_stmt)
  if (_internal_has_alter_event_trig_stmt()) {
    clear_has_node();
    ::pg_query::AlterEventTrigStmt* temp = node_.alter_event_trig_stmt_;
    node_.alter_event_trig_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_event_trig_stmt(::pg_query::AlterEventTrigStmt* alter_event_trig_stmt) {
  clear_node();
  if (alter_event_trig_stmt) {
    set_has_alter_event_trig_stmt();
    node_.alter_event_trig_stmt_ = alter_event_trig_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_event_trig_stmt)
}
inline ::pg_query::AlterEventTrigStmt* Node::_internal_mutable_alter_event_trig_stmt() {
  if (!_internal_has_alter_event_trig_stmt()) {
    clear_node();
    set_has_alter_event_trig_stmt();
    node_.alter_event_trig_stmt_ = CreateMaybeMessage< ::pg_query::AlterEventTrigStmt >(GetArena());
  }
  return node_.alter_event_trig_stmt_;
}
inline ::pg_query::AlterEventTrigStmt* Node::mutable_alter_event_trig_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_event_trig_stmt)
  return _internal_mutable_alter_event_trig_stmt();
}

// .pg_query.RefreshMatViewStmt refresh_mat_view_stmt = 151 [json_name = "RefreshMatViewStmt"];
inline bool Node::_internal_has_refresh_mat_view_stmt() const {
  return node_case() == kRefreshMatViewStmt;
}
inline bool Node::has_refresh_mat_view_stmt() const {
  return _internal_has_refresh_mat_view_stmt();
}
inline void Node::set_has_refresh_mat_view_stmt() {
  _oneof_case_[0] = kRefreshMatViewStmt;
}
inline void Node::clear_refresh_mat_view_stmt() {
  if (_internal_has_refresh_mat_view_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.refresh_mat_view_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RefreshMatViewStmt* Node::release_refresh_mat_view_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.refresh_mat_view_stmt)
  if (_internal_has_refresh_mat_view_stmt()) {
    clear_has_node();
      ::pg_query::RefreshMatViewStmt* temp = node_.refresh_mat_view_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.refresh_mat_view_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RefreshMatViewStmt& Node::_internal_refresh_mat_view_stmt() const {
  return _internal_has_refresh_mat_view_stmt()
      ? *node_.refresh_mat_view_stmt_
      : reinterpret_cast< ::pg_query::RefreshMatViewStmt&>(::pg_query::_RefreshMatViewStmt_default_instance_);
}
inline const ::pg_query::RefreshMatViewStmt& Node::refresh_mat_view_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.refresh_mat_view_stmt)
  return _internal_refresh_mat_view_stmt();
}
inline ::pg_query::RefreshMatViewStmt* Node::unsafe_arena_release_refresh_mat_view_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.refresh_mat_view_stmt)
  if (_internal_has_refresh_mat_view_stmt()) {
    clear_has_node();
    ::pg_query::RefreshMatViewStmt* temp = node_.refresh_mat_view_stmt_;
    node_.refresh_mat_view_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_refresh_mat_view_stmt(::pg_query::RefreshMatViewStmt* refresh_mat_view_stmt) {
  clear_node();
  if (refresh_mat_view_stmt) {
    set_has_refresh_mat_view_stmt();
    node_.refresh_mat_view_stmt_ = refresh_mat_view_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.refresh_mat_view_stmt)
}
inline ::pg_query::RefreshMatViewStmt* Node::_internal_mutable_refresh_mat_view_stmt() {
  if (!_internal_has_refresh_mat_view_stmt()) {
    clear_node();
    set_has_refresh_mat_view_stmt();
    node_.refresh_mat_view_stmt_ = CreateMaybeMessage< ::pg_query::RefreshMatViewStmt >(GetArena());
  }
  return node_.refresh_mat_view_stmt_;
}
inline ::pg_query::RefreshMatViewStmt* Node::mutable_refresh_mat_view_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.refresh_mat_view_stmt)
  return _internal_mutable_refresh_mat_view_stmt();
}

// .pg_query.ReplicaIdentityStmt replica_identity_stmt = 152 [json_name = "ReplicaIdentityStmt"];
inline bool Node::_internal_has_replica_identity_stmt() const {
  return node_case() == kReplicaIdentityStmt;
}
inline bool Node::has_replica_identity_stmt() const {
  return _internal_has_replica_identity_stmt();
}
inline void Node::set_has_replica_identity_stmt() {
  _oneof_case_[0] = kReplicaIdentityStmt;
}
inline void Node::clear_replica_identity_stmt() {
  if (_internal_has_replica_identity_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.replica_identity_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ReplicaIdentityStmt* Node::release_replica_identity_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.replica_identity_stmt)
  if (_internal_has_replica_identity_stmt()) {
    clear_has_node();
      ::pg_query::ReplicaIdentityStmt* temp = node_.replica_identity_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.replica_identity_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ReplicaIdentityStmt& Node::_internal_replica_identity_stmt() const {
  return _internal_has_replica_identity_stmt()
      ? *node_.replica_identity_stmt_
      : reinterpret_cast< ::pg_query::ReplicaIdentityStmt&>(::pg_query::_ReplicaIdentityStmt_default_instance_);
}
inline const ::pg_query::ReplicaIdentityStmt& Node::replica_identity_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.replica_identity_stmt)
  return _internal_replica_identity_stmt();
}
inline ::pg_query::ReplicaIdentityStmt* Node::unsafe_arena_release_replica_identity_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.replica_identity_stmt)
  if (_internal_has_replica_identity_stmt()) {
    clear_has_node();
    ::pg_query::ReplicaIdentityStmt* temp = node_.replica_identity_stmt_;
    node_.replica_identity_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_replica_identity_stmt(::pg_query::ReplicaIdentityStmt* replica_identity_stmt) {
  clear_node();
  if (replica_identity_stmt) {
    set_has_replica_identity_stmt();
    node_.replica_identity_stmt_ = replica_identity_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.replica_identity_stmt)
}
inline ::pg_query::ReplicaIdentityStmt* Node::_internal_mutable_replica_identity_stmt() {
  if (!_internal_has_replica_identity_stmt()) {
    clear_node();
    set_has_replica_identity_stmt();
    node_.replica_identity_stmt_ = CreateMaybeMessage< ::pg_query::ReplicaIdentityStmt >(GetArena());
  }
  return node_.replica_identity_stmt_;
}
inline ::pg_query::ReplicaIdentityStmt* Node::mutable_replica_identity_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.replica_identity_stmt)
  return _internal_mutable_replica_identity_stmt();
}

// .pg_query.AlterSystemStmt alter_system_stmt = 153 [json_name = "AlterSystemStmt"];
inline bool Node::_internal_has_alter_system_stmt() const {
  return node_case() == kAlterSystemStmt;
}
inline bool Node::has_alter_system_stmt() const {
  return _internal_has_alter_system_stmt();
}
inline void Node::set_has_alter_system_stmt() {
  _oneof_case_[0] = kAlterSystemStmt;
}
inline void Node::clear_alter_system_stmt() {
  if (_internal_has_alter_system_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_system_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterSystemStmt* Node::release_alter_system_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_system_stmt)
  if (_internal_has_alter_system_stmt()) {
    clear_has_node();
      ::pg_query::AlterSystemStmt* temp = node_.alter_system_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_system_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterSystemStmt& Node::_internal_alter_system_stmt() const {
  return _internal_has_alter_system_stmt()
      ? *node_.alter_system_stmt_
      : reinterpret_cast< ::pg_query::AlterSystemStmt&>(::pg_query::_AlterSystemStmt_default_instance_);
}
inline const ::pg_query::AlterSystemStmt& Node::alter_system_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_system_stmt)
  return _internal_alter_system_stmt();
}
inline ::pg_query::AlterSystemStmt* Node::unsafe_arena_release_alter_system_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_system_stmt)
  if (_internal_has_alter_system_stmt()) {
    clear_has_node();
    ::pg_query::AlterSystemStmt* temp = node_.alter_system_stmt_;
    node_.alter_system_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_system_stmt(::pg_query::AlterSystemStmt* alter_system_stmt) {
  clear_node();
  if (alter_system_stmt) {
    set_has_alter_system_stmt();
    node_.alter_system_stmt_ = alter_system_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_system_stmt)
}
inline ::pg_query::AlterSystemStmt* Node::_internal_mutable_alter_system_stmt() {
  if (!_internal_has_alter_system_stmt()) {
    clear_node();
    set_has_alter_system_stmt();
    node_.alter_system_stmt_ = CreateMaybeMessage< ::pg_query::AlterSystemStmt >(GetArena());
  }
  return node_.alter_system_stmt_;
}
inline ::pg_query::AlterSystemStmt* Node::mutable_alter_system_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_system_stmt)
  return _internal_mutable_alter_system_stmt();
}

// .pg_query.CreatePolicyStmt create_policy_stmt = 154 [json_name = "CreatePolicyStmt"];
inline bool Node::_internal_has_create_policy_stmt() const {
  return node_case() == kCreatePolicyStmt;
}
inline bool Node::has_create_policy_stmt() const {
  return _internal_has_create_policy_stmt();
}
inline void Node::set_has_create_policy_stmt() {
  _oneof_case_[0] = kCreatePolicyStmt;
}
inline void Node::clear_create_policy_stmt() {
  if (_internal_has_create_policy_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_policy_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreatePolicyStmt* Node::release_create_policy_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_policy_stmt)
  if (_internal_has_create_policy_stmt()) {
    clear_has_node();
      ::pg_query::CreatePolicyStmt* temp = node_.create_policy_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_policy_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreatePolicyStmt& Node::_internal_create_policy_stmt() const {
  return _internal_has_create_policy_stmt()
      ? *node_.create_policy_stmt_
      : reinterpret_cast< ::pg_query::CreatePolicyStmt&>(::pg_query::_CreatePolicyStmt_default_instance_);
}
inline const ::pg_query::CreatePolicyStmt& Node::create_policy_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_policy_stmt)
  return _internal_create_policy_stmt();
}
inline ::pg_query::CreatePolicyStmt* Node::unsafe_arena_release_create_policy_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_policy_stmt)
  if (_internal_has_create_policy_stmt()) {
    clear_has_node();
    ::pg_query::CreatePolicyStmt* temp = node_.create_policy_stmt_;
    node_.create_policy_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_policy_stmt(::pg_query::CreatePolicyStmt* create_policy_stmt) {
  clear_node();
  if (create_policy_stmt) {
    set_has_create_policy_stmt();
    node_.create_policy_stmt_ = create_policy_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_policy_stmt)
}
inline ::pg_query::CreatePolicyStmt* Node::_internal_mutable_create_policy_stmt() {
  if (!_internal_has_create_policy_stmt()) {
    clear_node();
    set_has_create_policy_stmt();
    node_.create_policy_stmt_ = CreateMaybeMessage< ::pg_query::CreatePolicyStmt >(GetArena());
  }
  return node_.create_policy_stmt_;
}
inline ::pg_query::CreatePolicyStmt* Node::mutable_create_policy_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_policy_stmt)
  return _internal_mutable_create_policy_stmt();
}

// .pg_query.AlterPolicyStmt alter_policy_stmt = 155 [json_name = "AlterPolicyStmt"];
inline bool Node::_internal_has_alter_policy_stmt() const {
  return node_case() == kAlterPolicyStmt;
}
inline bool Node::has_alter_policy_stmt() const {
  return _internal_has_alter_policy_stmt();
}
inline void Node::set_has_alter_policy_stmt() {
  _oneof_case_[0] = kAlterPolicyStmt;
}
inline void Node::clear_alter_policy_stmt() {
  if (_internal_has_alter_policy_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_policy_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterPolicyStmt* Node::release_alter_policy_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_policy_stmt)
  if (_internal_has_alter_policy_stmt()) {
    clear_has_node();
      ::pg_query::AlterPolicyStmt* temp = node_.alter_policy_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_policy_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterPolicyStmt& Node::_internal_alter_policy_stmt() const {
  return _internal_has_alter_policy_stmt()
      ? *node_.alter_policy_stmt_
      : reinterpret_cast< ::pg_query::AlterPolicyStmt&>(::pg_query::_AlterPolicyStmt_default_instance_);
}
inline const ::pg_query::AlterPolicyStmt& Node::alter_policy_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_policy_stmt)
  return _internal_alter_policy_stmt();
}
inline ::pg_query::AlterPolicyStmt* Node::unsafe_arena_release_alter_policy_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_policy_stmt)
  if (_internal_has_alter_policy_stmt()) {
    clear_has_node();
    ::pg_query::AlterPolicyStmt* temp = node_.alter_policy_stmt_;
    node_.alter_policy_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_policy_stmt(::pg_query::AlterPolicyStmt* alter_policy_stmt) {
  clear_node();
  if (alter_policy_stmt) {
    set_has_alter_policy_stmt();
    node_.alter_policy_stmt_ = alter_policy_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_policy_stmt)
}
inline ::pg_query::AlterPolicyStmt* Node::_internal_mutable_alter_policy_stmt() {
  if (!_internal_has_alter_policy_stmt()) {
    clear_node();
    set_has_alter_policy_stmt();
    node_.alter_policy_stmt_ = CreateMaybeMessage< ::pg_query::AlterPolicyStmt >(GetArena());
  }
  return node_.alter_policy_stmt_;
}
inline ::pg_query::AlterPolicyStmt* Node::mutable_alter_policy_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_policy_stmt)
  return _internal_mutable_alter_policy_stmt();
}

// .pg_query.CreateTransformStmt create_transform_stmt = 156 [json_name = "CreateTransformStmt"];
inline bool Node::_internal_has_create_transform_stmt() const {
  return node_case() == kCreateTransformStmt;
}
inline bool Node::has_create_transform_stmt() const {
  return _internal_has_create_transform_stmt();
}
inline void Node::set_has_create_transform_stmt() {
  _oneof_case_[0] = kCreateTransformStmt;
}
inline void Node::clear_create_transform_stmt() {
  if (_internal_has_create_transform_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_transform_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateTransformStmt* Node::release_create_transform_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_transform_stmt)
  if (_internal_has_create_transform_stmt()) {
    clear_has_node();
      ::pg_query::CreateTransformStmt* temp = node_.create_transform_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_transform_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateTransformStmt& Node::_internal_create_transform_stmt() const {
  return _internal_has_create_transform_stmt()
      ? *node_.create_transform_stmt_
      : reinterpret_cast< ::pg_query::CreateTransformStmt&>(::pg_query::_CreateTransformStmt_default_instance_);
}
inline const ::pg_query::CreateTransformStmt& Node::create_transform_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_transform_stmt)
  return _internal_create_transform_stmt();
}
inline ::pg_query::CreateTransformStmt* Node::unsafe_arena_release_create_transform_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_transform_stmt)
  if (_internal_has_create_transform_stmt()) {
    clear_has_node();
    ::pg_query::CreateTransformStmt* temp = node_.create_transform_stmt_;
    node_.create_transform_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_transform_stmt(::pg_query::CreateTransformStmt* create_transform_stmt) {
  clear_node();
  if (create_transform_stmt) {
    set_has_create_transform_stmt();
    node_.create_transform_stmt_ = create_transform_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_transform_stmt)
}
inline ::pg_query::CreateTransformStmt* Node::_internal_mutable_create_transform_stmt() {
  if (!_internal_has_create_transform_stmt()) {
    clear_node();
    set_has_create_transform_stmt();
    node_.create_transform_stmt_ = CreateMaybeMessage< ::pg_query::CreateTransformStmt >(GetArena());
  }
  return node_.create_transform_stmt_;
}
inline ::pg_query::CreateTransformStmt* Node::mutable_create_transform_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_transform_stmt)
  return _internal_mutable_create_transform_stmt();
}

// .pg_query.CreateAmStmt create_am_stmt = 157 [json_name = "CreateAmStmt"];
inline bool Node::_internal_has_create_am_stmt() const {
  return node_case() == kCreateAmStmt;
}
inline bool Node::has_create_am_stmt() const {
  return _internal_has_create_am_stmt();
}
inline void Node::set_has_create_am_stmt() {
  _oneof_case_[0] = kCreateAmStmt;
}
inline void Node::clear_create_am_stmt() {
  if (_internal_has_create_am_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_am_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateAmStmt* Node::release_create_am_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_am_stmt)
  if (_internal_has_create_am_stmt()) {
    clear_has_node();
      ::pg_query::CreateAmStmt* temp = node_.create_am_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_am_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateAmStmt& Node::_internal_create_am_stmt() const {
  return _internal_has_create_am_stmt()
      ? *node_.create_am_stmt_
      : reinterpret_cast< ::pg_query::CreateAmStmt&>(::pg_query::_CreateAmStmt_default_instance_);
}
inline const ::pg_query::CreateAmStmt& Node::create_am_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_am_stmt)
  return _internal_create_am_stmt();
}
inline ::pg_query::CreateAmStmt* Node::unsafe_arena_release_create_am_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_am_stmt)
  if (_internal_has_create_am_stmt()) {
    clear_has_node();
    ::pg_query::CreateAmStmt* temp = node_.create_am_stmt_;
    node_.create_am_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_am_stmt(::pg_query::CreateAmStmt* create_am_stmt) {
  clear_node();
  if (create_am_stmt) {
    set_has_create_am_stmt();
    node_.create_am_stmt_ = create_am_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_am_stmt)
}
inline ::pg_query::CreateAmStmt* Node::_internal_mutable_create_am_stmt() {
  if (!_internal_has_create_am_stmt()) {
    clear_node();
    set_has_create_am_stmt();
    node_.create_am_stmt_ = CreateMaybeMessage< ::pg_query::CreateAmStmt >(GetArena());
  }
  return node_.create_am_stmt_;
}
inline ::pg_query::CreateAmStmt* Node::mutable_create_am_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_am_stmt)
  return _internal_mutable_create_am_stmt();
}

// .pg_query.CreatePublicationStmt create_publication_stmt = 158 [json_name = "CreatePublicationStmt"];
inline bool Node::_internal_has_create_publication_stmt() const {
  return node_case() == kCreatePublicationStmt;
}
inline bool Node::has_create_publication_stmt() const {
  return _internal_has_create_publication_stmt();
}
inline void Node::set_has_create_publication_stmt() {
  _oneof_case_[0] = kCreatePublicationStmt;
}
inline void Node::clear_create_publication_stmt() {
  if (_internal_has_create_publication_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_publication_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreatePublicationStmt* Node::release_create_publication_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_publication_stmt)
  if (_internal_has_create_publication_stmt()) {
    clear_has_node();
      ::pg_query::CreatePublicationStmt* temp = node_.create_publication_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_publication_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreatePublicationStmt& Node::_internal_create_publication_stmt() const {
  return _internal_has_create_publication_stmt()
      ? *node_.create_publication_stmt_
      : reinterpret_cast< ::pg_query::CreatePublicationStmt&>(::pg_query::_CreatePublicationStmt_default_instance_);
}
inline const ::pg_query::CreatePublicationStmt& Node::create_publication_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_publication_stmt)
  return _internal_create_publication_stmt();
}
inline ::pg_query::CreatePublicationStmt* Node::unsafe_arena_release_create_publication_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_publication_stmt)
  if (_internal_has_create_publication_stmt()) {
    clear_has_node();
    ::pg_query::CreatePublicationStmt* temp = node_.create_publication_stmt_;
    node_.create_publication_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_publication_stmt(::pg_query::CreatePublicationStmt* create_publication_stmt) {
  clear_node();
  if (create_publication_stmt) {
    set_has_create_publication_stmt();
    node_.create_publication_stmt_ = create_publication_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_publication_stmt)
}
inline ::pg_query::CreatePublicationStmt* Node::_internal_mutable_create_publication_stmt() {
  if (!_internal_has_create_publication_stmt()) {
    clear_node();
    set_has_create_publication_stmt();
    node_.create_publication_stmt_ = CreateMaybeMessage< ::pg_query::CreatePublicationStmt >(GetArena());
  }
  return node_.create_publication_stmt_;
}
inline ::pg_query::CreatePublicationStmt* Node::mutable_create_publication_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_publication_stmt)
  return _internal_mutable_create_publication_stmt();
}

// .pg_query.AlterPublicationStmt alter_publication_stmt = 159 [json_name = "AlterPublicationStmt"];
inline bool Node::_internal_has_alter_publication_stmt() const {
  return node_case() == kAlterPublicationStmt;
}
inline bool Node::has_alter_publication_stmt() const {
  return _internal_has_alter_publication_stmt();
}
inline void Node::set_has_alter_publication_stmt() {
  _oneof_case_[0] = kAlterPublicationStmt;
}
inline void Node::clear_alter_publication_stmt() {
  if (_internal_has_alter_publication_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_publication_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterPublicationStmt* Node::release_alter_publication_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_publication_stmt)
  if (_internal_has_alter_publication_stmt()) {
    clear_has_node();
      ::pg_query::AlterPublicationStmt* temp = node_.alter_publication_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_publication_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterPublicationStmt& Node::_internal_alter_publication_stmt() const {
  return _internal_has_alter_publication_stmt()
      ? *node_.alter_publication_stmt_
      : reinterpret_cast< ::pg_query::AlterPublicationStmt&>(::pg_query::_AlterPublicationStmt_default_instance_);
}
inline const ::pg_query::AlterPublicationStmt& Node::alter_publication_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_publication_stmt)
  return _internal_alter_publication_stmt();
}
inline ::pg_query::AlterPublicationStmt* Node::unsafe_arena_release_alter_publication_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_publication_stmt)
  if (_internal_has_alter_publication_stmt()) {
    clear_has_node();
    ::pg_query::AlterPublicationStmt* temp = node_.alter_publication_stmt_;
    node_.alter_publication_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_publication_stmt(::pg_query::AlterPublicationStmt* alter_publication_stmt) {
  clear_node();
  if (alter_publication_stmt) {
    set_has_alter_publication_stmt();
    node_.alter_publication_stmt_ = alter_publication_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_publication_stmt)
}
inline ::pg_query::AlterPublicationStmt* Node::_internal_mutable_alter_publication_stmt() {
  if (!_internal_has_alter_publication_stmt()) {
    clear_node();
    set_has_alter_publication_stmt();
    node_.alter_publication_stmt_ = CreateMaybeMessage< ::pg_query::AlterPublicationStmt >(GetArena());
  }
  return node_.alter_publication_stmt_;
}
inline ::pg_query::AlterPublicationStmt* Node::mutable_alter_publication_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_publication_stmt)
  return _internal_mutable_alter_publication_stmt();
}

// .pg_query.CreateSubscriptionStmt create_subscription_stmt = 160 [json_name = "CreateSubscriptionStmt"];
inline bool Node::_internal_has_create_subscription_stmt() const {
  return node_case() == kCreateSubscriptionStmt;
}
inline bool Node::has_create_subscription_stmt() const {
  return _internal_has_create_subscription_stmt();
}
inline void Node::set_has_create_subscription_stmt() {
  _oneof_case_[0] = kCreateSubscriptionStmt;
}
inline void Node::clear_create_subscription_stmt() {
  if (_internal_has_create_subscription_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_subscription_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateSubscriptionStmt* Node::release_create_subscription_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_subscription_stmt)
  if (_internal_has_create_subscription_stmt()) {
    clear_has_node();
      ::pg_query::CreateSubscriptionStmt* temp = node_.create_subscription_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_subscription_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateSubscriptionStmt& Node::_internal_create_subscription_stmt() const {
  return _internal_has_create_subscription_stmt()
      ? *node_.create_subscription_stmt_
      : reinterpret_cast< ::pg_query::CreateSubscriptionStmt&>(::pg_query::_CreateSubscriptionStmt_default_instance_);
}
inline const ::pg_query::CreateSubscriptionStmt& Node::create_subscription_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_subscription_stmt)
  return _internal_create_subscription_stmt();
}
inline ::pg_query::CreateSubscriptionStmt* Node::unsafe_arena_release_create_subscription_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_subscription_stmt)
  if (_internal_has_create_subscription_stmt()) {
    clear_has_node();
    ::pg_query::CreateSubscriptionStmt* temp = node_.create_subscription_stmt_;
    node_.create_subscription_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_subscription_stmt(::pg_query::CreateSubscriptionStmt* create_subscription_stmt) {
  clear_node();
  if (create_subscription_stmt) {
    set_has_create_subscription_stmt();
    node_.create_subscription_stmt_ = create_subscription_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_subscription_stmt)
}
inline ::pg_query::CreateSubscriptionStmt* Node::_internal_mutable_create_subscription_stmt() {
  if (!_internal_has_create_subscription_stmt()) {
    clear_node();
    set_has_create_subscription_stmt();
    node_.create_subscription_stmt_ = CreateMaybeMessage< ::pg_query::CreateSubscriptionStmt >(GetArena());
  }
  return node_.create_subscription_stmt_;
}
inline ::pg_query::CreateSubscriptionStmt* Node::mutable_create_subscription_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_subscription_stmt)
  return _internal_mutable_create_subscription_stmt();
}

// .pg_query.AlterSubscriptionStmt alter_subscription_stmt = 161 [json_name = "AlterSubscriptionStmt"];
inline bool Node::_internal_has_alter_subscription_stmt() const {
  return node_case() == kAlterSubscriptionStmt;
}
inline bool Node::has_alter_subscription_stmt() const {
  return _internal_has_alter_subscription_stmt();
}
inline void Node::set_has_alter_subscription_stmt() {
  _oneof_case_[0] = kAlterSubscriptionStmt;
}
inline void Node::clear_alter_subscription_stmt() {
  if (_internal_has_alter_subscription_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_subscription_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterSubscriptionStmt* Node::release_alter_subscription_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_subscription_stmt)
  if (_internal_has_alter_subscription_stmt()) {
    clear_has_node();
      ::pg_query::AlterSubscriptionStmt* temp = node_.alter_subscription_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_subscription_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterSubscriptionStmt& Node::_internal_alter_subscription_stmt() const {
  return _internal_has_alter_subscription_stmt()
      ? *node_.alter_subscription_stmt_
      : reinterpret_cast< ::pg_query::AlterSubscriptionStmt&>(::pg_query::_AlterSubscriptionStmt_default_instance_);
}
inline const ::pg_query::AlterSubscriptionStmt& Node::alter_subscription_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_subscription_stmt)
  return _internal_alter_subscription_stmt();
}
inline ::pg_query::AlterSubscriptionStmt* Node::unsafe_arena_release_alter_subscription_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_subscription_stmt)
  if (_internal_has_alter_subscription_stmt()) {
    clear_has_node();
    ::pg_query::AlterSubscriptionStmt* temp = node_.alter_subscription_stmt_;
    node_.alter_subscription_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_subscription_stmt(::pg_query::AlterSubscriptionStmt* alter_subscription_stmt) {
  clear_node();
  if (alter_subscription_stmt) {
    set_has_alter_subscription_stmt();
    node_.alter_subscription_stmt_ = alter_subscription_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_subscription_stmt)
}
inline ::pg_query::AlterSubscriptionStmt* Node::_internal_mutable_alter_subscription_stmt() {
  if (!_internal_has_alter_subscription_stmt()) {
    clear_node();
    set_has_alter_subscription_stmt();
    node_.alter_subscription_stmt_ = CreateMaybeMessage< ::pg_query::AlterSubscriptionStmt >(GetArena());
  }
  return node_.alter_subscription_stmt_;
}
inline ::pg_query::AlterSubscriptionStmt* Node::mutable_alter_subscription_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_subscription_stmt)
  return _internal_mutable_alter_subscription_stmt();
}

// .pg_query.DropSubscriptionStmt drop_subscription_stmt = 162 [json_name = "DropSubscriptionStmt"];
inline bool Node::_internal_has_drop_subscription_stmt() const {
  return node_case() == kDropSubscriptionStmt;
}
inline bool Node::has_drop_subscription_stmt() const {
  return _internal_has_drop_subscription_stmt();
}
inline void Node::set_has_drop_subscription_stmt() {
  _oneof_case_[0] = kDropSubscriptionStmt;
}
inline void Node::clear_drop_subscription_stmt() {
  if (_internal_has_drop_subscription_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.drop_subscription_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DropSubscriptionStmt* Node::release_drop_subscription_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.drop_subscription_stmt)
  if (_internal_has_drop_subscription_stmt()) {
    clear_has_node();
      ::pg_query::DropSubscriptionStmt* temp = node_.drop_subscription_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.drop_subscription_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropSubscriptionStmt& Node::_internal_drop_subscription_stmt() const {
  return _internal_has_drop_subscription_stmt()
      ? *node_.drop_subscription_stmt_
      : reinterpret_cast< ::pg_query::DropSubscriptionStmt&>(::pg_query::_DropSubscriptionStmt_default_instance_);
}
inline const ::pg_query::DropSubscriptionStmt& Node::drop_subscription_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.drop_subscription_stmt)
  return _internal_drop_subscription_stmt();
}
inline ::pg_query::DropSubscriptionStmt* Node::unsafe_arena_release_drop_subscription_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.drop_subscription_stmt)
  if (_internal_has_drop_subscription_stmt()) {
    clear_has_node();
    ::pg_query::DropSubscriptionStmt* temp = node_.drop_subscription_stmt_;
    node_.drop_subscription_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_drop_subscription_stmt(::pg_query::DropSubscriptionStmt* drop_subscription_stmt) {
  clear_node();
  if (drop_subscription_stmt) {
    set_has_drop_subscription_stmt();
    node_.drop_subscription_stmt_ = drop_subscription_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.drop_subscription_stmt)
}
inline ::pg_query::DropSubscriptionStmt* Node::_internal_mutable_drop_subscription_stmt() {
  if (!_internal_has_drop_subscription_stmt()) {
    clear_node();
    set_has_drop_subscription_stmt();
    node_.drop_subscription_stmt_ = CreateMaybeMessage< ::pg_query::DropSubscriptionStmt >(GetArena());
  }
  return node_.drop_subscription_stmt_;
}
inline ::pg_query::DropSubscriptionStmt* Node::mutable_drop_subscription_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_subscription_stmt)
  return _internal_mutable_drop_subscription_stmt();
}

// .pg_query.CreateStatsStmt create_stats_stmt = 163 [json_name = "CreateStatsStmt"];
inline bool Node::_internal_has_create_stats_stmt() const {
  return node_case() == kCreateStatsStmt;
}
inline bool Node::has_create_stats_stmt() const {
  return _internal_has_create_stats_stmt();
}
inline void Node::set_has_create_stats_stmt() {
  _oneof_case_[0] = kCreateStatsStmt;
}
inline void Node::clear_create_stats_stmt() {
  if (_internal_has_create_stats_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.create_stats_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateStatsStmt* Node::release_create_stats_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_stats_stmt)
  if (_internal_has_create_stats_stmt()) {
    clear_has_node();
      ::pg_query::CreateStatsStmt* temp = node_.create_stats_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_stats_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateStatsStmt& Node::_internal_create_stats_stmt() const {
  return _internal_has_create_stats_stmt()
      ? *node_.create_stats_stmt_
      : reinterpret_cast< ::pg_query::CreateStatsStmt&>(::pg_query::_CreateStatsStmt_default_instance_);
}
inline const ::pg_query::CreateStatsStmt& Node::create_stats_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_stats_stmt)
  return _internal_create_stats_stmt();
}
inline ::pg_query::CreateStatsStmt* Node::unsafe_arena_release_create_stats_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_stats_stmt)
  if (_internal_has_create_stats_stmt()) {
    clear_has_node();
    ::pg_query::CreateStatsStmt* temp = node_.create_stats_stmt_;
    node_.create_stats_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_stats_stmt(::pg_query::CreateStatsStmt* create_stats_stmt) {
  clear_node();
  if (create_stats_stmt) {
    set_has_create_stats_stmt();
    node_.create_stats_stmt_ = create_stats_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_stats_stmt)
}
inline ::pg_query::CreateStatsStmt* Node::_internal_mutable_create_stats_stmt() {
  if (!_internal_has_create_stats_stmt()) {
    clear_node();
    set_has_create_stats_stmt();
    node_.create_stats_stmt_ = CreateMaybeMessage< ::pg_query::CreateStatsStmt >(GetArena());
  }
  return node_.create_stats_stmt_;
}
inline ::pg_query::CreateStatsStmt* Node::mutable_create_stats_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_stats_stmt)
  return _internal_mutable_create_stats_stmt();
}

// .pg_query.AlterCollationStmt alter_collation_stmt = 164 [json_name = "AlterCollationStmt"];
inline bool Node::_internal_has_alter_collation_stmt() const {
  return node_case() == kAlterCollationStmt;
}
inline bool Node::has_alter_collation_stmt() const {
  return _internal_has_alter_collation_stmt();
}
inline void Node::set_has_alter_collation_stmt() {
  _oneof_case_[0] = kAlterCollationStmt;
}
inline void Node::clear_alter_collation_stmt() {
  if (_internal_has_alter_collation_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_collation_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterCollationStmt* Node::release_alter_collation_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_collation_stmt)
  if (_internal_has_alter_collation_stmt()) {
    clear_has_node();
      ::pg_query::AlterCollationStmt* temp = node_.alter_collation_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_collation_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterCollationStmt& Node::_internal_alter_collation_stmt() const {
  return _internal_has_alter_collation_stmt()
      ? *node_.alter_collation_stmt_
      : reinterpret_cast< ::pg_query::AlterCollationStmt&>(::pg_query::_AlterCollationStmt_default_instance_);
}
inline const ::pg_query::AlterCollationStmt& Node::alter_collation_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_collation_stmt)
  return _internal_alter_collation_stmt();
}
inline ::pg_query::AlterCollationStmt* Node::unsafe_arena_release_alter_collation_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_collation_stmt)
  if (_internal_has_alter_collation_stmt()) {
    clear_has_node();
    ::pg_query::AlterCollationStmt* temp = node_.alter_collation_stmt_;
    node_.alter_collation_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_collation_stmt(::pg_query::AlterCollationStmt* alter_collation_stmt) {
  clear_node();
  if (alter_collation_stmt) {
    set_has_alter_collation_stmt();
    node_.alter_collation_stmt_ = alter_collation_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_collation_stmt)
}
inline ::pg_query::AlterCollationStmt* Node::_internal_mutable_alter_collation_stmt() {
  if (!_internal_has_alter_collation_stmt()) {
    clear_node();
    set_has_alter_collation_stmt();
    node_.alter_collation_stmt_ = CreateMaybeMessage< ::pg_query::AlterCollationStmt >(GetArena());
  }
  return node_.alter_collation_stmt_;
}
inline ::pg_query::AlterCollationStmt* Node::mutable_alter_collation_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_collation_stmt)
  return _internal_mutable_alter_collation_stmt();
}

// .pg_query.CallStmt call_stmt = 165 [json_name = "CallStmt"];
inline bool Node::_internal_has_call_stmt() const {
  return node_case() == kCallStmt;
}
inline bool Node::has_call_stmt() const {
  return _internal_has_call_stmt();
}
inline void Node::set_has_call_stmt() {
  _oneof_case_[0] = kCallStmt;
}
inline void Node::clear_call_stmt() {
  if (_internal_has_call_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.call_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CallStmt* Node::release_call_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.call_stmt)
  if (_internal_has_call_stmt()) {
    clear_has_node();
      ::pg_query::CallStmt* temp = node_.call_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.call_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CallStmt& Node::_internal_call_stmt() const {
  return _internal_has_call_stmt()
      ? *node_.call_stmt_
      : reinterpret_cast< ::pg_query::CallStmt&>(::pg_query::_CallStmt_default_instance_);
}
inline const ::pg_query::CallStmt& Node::call_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.call_stmt)
  return _internal_call_stmt();
}
inline ::pg_query::CallStmt* Node::unsafe_arena_release_call_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.call_stmt)
  if (_internal_has_call_stmt()) {
    clear_has_node();
    ::pg_query::CallStmt* temp = node_.call_stmt_;
    node_.call_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_call_stmt(::pg_query::CallStmt* call_stmt) {
  clear_node();
  if (call_stmt) {
    set_has_call_stmt();
    node_.call_stmt_ = call_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.call_stmt)
}
inline ::pg_query::CallStmt* Node::_internal_mutable_call_stmt() {
  if (!_internal_has_call_stmt()) {
    clear_node();
    set_has_call_stmt();
    node_.call_stmt_ = CreateMaybeMessage< ::pg_query::CallStmt >(GetArena());
  }
  return node_.call_stmt_;
}
inline ::pg_query::CallStmt* Node::mutable_call_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.call_stmt)
  return _internal_mutable_call_stmt();
}

// .pg_query.AlterStatsStmt alter_stats_stmt = 166 [json_name = "AlterStatsStmt"];
inline bool Node::_internal_has_alter_stats_stmt() const {
  return node_case() == kAlterStatsStmt;
}
inline bool Node::has_alter_stats_stmt() const {
  return _internal_has_alter_stats_stmt();
}
inline void Node::set_has_alter_stats_stmt() {
  _oneof_case_[0] = kAlterStatsStmt;
}
inline void Node::clear_alter_stats_stmt() {
  if (_internal_has_alter_stats_stmt()) {
    if (GetArena() == nullptr) {
      delete node_.alter_stats_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterStatsStmt* Node::release_alter_stats_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_stats_stmt)
  if (_internal_has_alter_stats_stmt()) {
    clear_has_node();
      ::pg_query::AlterStatsStmt* temp = node_.alter_stats_stmt_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.alter_stats_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterStatsStmt& Node::_internal_alter_stats_stmt() const {
  return _internal_has_alter_stats_stmt()
      ? *node_.alter_stats_stmt_
      : reinterpret_cast< ::pg_query::AlterStatsStmt&>(::pg_query::_AlterStatsStmt_default_instance_);
}
inline const ::pg_query::AlterStatsStmt& Node::alter_stats_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_stats_stmt)
  return _internal_alter_stats_stmt();
}
inline ::pg_query::AlterStatsStmt* Node::unsafe_arena_release_alter_stats_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_stats_stmt)
  if (_internal_has_alter_stats_stmt()) {
    clear_has_node();
    ::pg_query::AlterStatsStmt* temp = node_.alter_stats_stmt_;
    node_.alter_stats_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_stats_stmt(::pg_query::AlterStatsStmt* alter_stats_stmt) {
  clear_node();
  if (alter_stats_stmt) {
    set_has_alter_stats_stmt();
    node_.alter_stats_stmt_ = alter_stats_stmt;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_stats_stmt)
}
inline ::pg_query::AlterStatsStmt* Node::_internal_mutable_alter_stats_stmt() {
  if (!_internal_has_alter_stats_stmt()) {
    clear_node();
    set_has_alter_stats_stmt();
    node_.alter_stats_stmt_ = CreateMaybeMessage< ::pg_query::AlterStatsStmt >(GetArena());
  }
  return node_.alter_stats_stmt_;
}
inline ::pg_query::AlterStatsStmt* Node::mutable_alter_stats_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_stats_stmt)
  return _internal_mutable_alter_stats_stmt();
}

// .pg_query.A_Expr a_expr = 167 [json_name = "A_Expr"];
inline bool Node::_internal_has_a_expr() const {
  return node_case() == kAExpr;
}
inline bool Node::has_a_expr() const {
  return _internal_has_a_expr();
}
inline void Node::set_has_a_expr() {
  _oneof_case_[0] = kAExpr;
}
inline void Node::clear_a_expr() {
  if (_internal_has_a_expr()) {
    if (GetArena() == nullptr) {
      delete node_.a_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::A_Expr* Node::release_a_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.a_expr)
  if (_internal_has_a_expr()) {
    clear_has_node();
      ::pg_query::A_Expr* temp = node_.a_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.a_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::A_Expr& Node::_internal_a_expr() const {
  return _internal_has_a_expr()
      ? *node_.a_expr_
      : reinterpret_cast< ::pg_query::A_Expr&>(::pg_query::_A_Expr_default_instance_);
}
inline const ::pg_query::A_Expr& Node::a_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.a_expr)
  return _internal_a_expr();
}
inline ::pg_query::A_Expr* Node::unsafe_arena_release_a_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.a_expr)
  if (_internal_has_a_expr()) {
    clear_has_node();
    ::pg_query::A_Expr* temp = node_.a_expr_;
    node_.a_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_a_expr(::pg_query::A_Expr* a_expr) {
  clear_node();
  if (a_expr) {
    set_has_a_expr();
    node_.a_expr_ = a_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_expr)
}
inline ::pg_query::A_Expr* Node::_internal_mutable_a_expr() {
  if (!_internal_has_a_expr()) {
    clear_node();
    set_has_a_expr();
    node_.a_expr_ = CreateMaybeMessage< ::pg_query::A_Expr >(GetArena());
  }
  return node_.a_expr_;
}
inline ::pg_query::A_Expr* Node::mutable_a_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.a_expr)
  return _internal_mutable_a_expr();
}

// .pg_query.ColumnRef column_ref = 168 [json_name = "ColumnRef"];
inline bool Node::_internal_has_column_ref() const {
  return node_case() == kColumnRef;
}
inline bool Node::has_column_ref() const {
  return _internal_has_column_ref();
}
inline void Node::set_has_column_ref() {
  _oneof_case_[0] = kColumnRef;
}
inline void Node::clear_column_ref() {
  if (_internal_has_column_ref()) {
    if (GetArena() == nullptr) {
      delete node_.column_ref_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ColumnRef* Node::release_column_ref() {
  // @@protoc_insertion_point(field_release:pg_query.Node.column_ref)
  if (_internal_has_column_ref()) {
    clear_has_node();
      ::pg_query::ColumnRef* temp = node_.column_ref_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.column_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ColumnRef& Node::_internal_column_ref() const {
  return _internal_has_column_ref()
      ? *node_.column_ref_
      : reinterpret_cast< ::pg_query::ColumnRef&>(::pg_query::_ColumnRef_default_instance_);
}
inline const ::pg_query::ColumnRef& Node::column_ref() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.column_ref)
  return _internal_column_ref();
}
inline ::pg_query::ColumnRef* Node::unsafe_arena_release_column_ref() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.column_ref)
  if (_internal_has_column_ref()) {
    clear_has_node();
    ::pg_query::ColumnRef* temp = node_.column_ref_;
    node_.column_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_column_ref(::pg_query::ColumnRef* column_ref) {
  clear_node();
  if (column_ref) {
    set_has_column_ref();
    node_.column_ref_ = column_ref;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.column_ref)
}
inline ::pg_query::ColumnRef* Node::_internal_mutable_column_ref() {
  if (!_internal_has_column_ref()) {
    clear_node();
    set_has_column_ref();
    node_.column_ref_ = CreateMaybeMessage< ::pg_query::ColumnRef >(GetArena());
  }
  return node_.column_ref_;
}
inline ::pg_query::ColumnRef* Node::mutable_column_ref() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.column_ref)
  return _internal_mutable_column_ref();
}

// .pg_query.ParamRef param_ref = 169 [json_name = "ParamRef"];
inline bool Node::_internal_has_param_ref() const {
  return node_case() == kParamRef;
}
inline bool Node::has_param_ref() const {
  return _internal_has_param_ref();
}
inline void Node::set_has_param_ref() {
  _oneof_case_[0] = kParamRef;
}
inline void Node::clear_param_ref() {
  if (_internal_has_param_ref()) {
    if (GetArena() == nullptr) {
      delete node_.param_ref_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ParamRef* Node::release_param_ref() {
  // @@protoc_insertion_point(field_release:pg_query.Node.param_ref)
  if (_internal_has_param_ref()) {
    clear_has_node();
      ::pg_query::ParamRef* temp = node_.param_ref_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.param_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ParamRef& Node::_internal_param_ref() const {
  return _internal_has_param_ref()
      ? *node_.param_ref_
      : reinterpret_cast< ::pg_query::ParamRef&>(::pg_query::_ParamRef_default_instance_);
}
inline const ::pg_query::ParamRef& Node::param_ref() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.param_ref)
  return _internal_param_ref();
}
inline ::pg_query::ParamRef* Node::unsafe_arena_release_param_ref() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.param_ref)
  if (_internal_has_param_ref()) {
    clear_has_node();
    ::pg_query::ParamRef* temp = node_.param_ref_;
    node_.param_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_param_ref(::pg_query::ParamRef* param_ref) {
  clear_node();
  if (param_ref) {
    set_has_param_ref();
    node_.param_ref_ = param_ref;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.param_ref)
}
inline ::pg_query::ParamRef* Node::_internal_mutable_param_ref() {
  if (!_internal_has_param_ref()) {
    clear_node();
    set_has_param_ref();
    node_.param_ref_ = CreateMaybeMessage< ::pg_query::ParamRef >(GetArena());
  }
  return node_.param_ref_;
}
inline ::pg_query::ParamRef* Node::mutable_param_ref() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.param_ref)
  return _internal_mutable_param_ref();
}

// .pg_query.A_Const a_const = 170 [json_name = "A_Const"];
inline bool Node::_internal_has_a_const() const {
  return node_case() == kAConst;
}
inline bool Node::has_a_const() const {
  return _internal_has_a_const();
}
inline void Node::set_has_a_const() {
  _oneof_case_[0] = kAConst;
}
inline void Node::clear_a_const() {
  if (_internal_has_a_const()) {
    if (GetArena() == nullptr) {
      delete node_.a_const_;
    }
    clear_has_node();
  }
}
inline ::pg_query::A_Const* Node::release_a_const() {
  // @@protoc_insertion_point(field_release:pg_query.Node.a_const)
  if (_internal_has_a_const()) {
    clear_has_node();
      ::pg_query::A_Const* temp = node_.a_const_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.a_const_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::A_Const& Node::_internal_a_const() const {
  return _internal_has_a_const()
      ? *node_.a_const_
      : reinterpret_cast< ::pg_query::A_Const&>(::pg_query::_A_Const_default_instance_);
}
inline const ::pg_query::A_Const& Node::a_const() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.a_const)
  return _internal_a_const();
}
inline ::pg_query::A_Const* Node::unsafe_arena_release_a_const() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.a_const)
  if (_internal_has_a_const()) {
    clear_has_node();
    ::pg_query::A_Const* temp = node_.a_const_;
    node_.a_const_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_a_const(::pg_query::A_Const* a_const) {
  clear_node();
  if (a_const) {
    set_has_a_const();
    node_.a_const_ = a_const;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_const)
}
inline ::pg_query::A_Const* Node::_internal_mutable_a_const() {
  if (!_internal_has_a_const()) {
    clear_node();
    set_has_a_const();
    node_.a_const_ = CreateMaybeMessage< ::pg_query::A_Const >(GetArena());
  }
  return node_.a_const_;
}
inline ::pg_query::A_Const* Node::mutable_a_const() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.a_const)
  return _internal_mutable_a_const();
}

// .pg_query.FuncCall func_call = 171 [json_name = "FuncCall"];
inline bool Node::_internal_has_func_call() const {
  return node_case() == kFuncCall;
}
inline bool Node::has_func_call() const {
  return _internal_has_func_call();
}
inline void Node::set_has_func_call() {
  _oneof_case_[0] = kFuncCall;
}
inline void Node::clear_func_call() {
  if (_internal_has_func_call()) {
    if (GetArena() == nullptr) {
      delete node_.func_call_;
    }
    clear_has_node();
  }
}
inline ::pg_query::FuncCall* Node::release_func_call() {
  // @@protoc_insertion_point(field_release:pg_query.Node.func_call)
  if (_internal_has_func_call()) {
    clear_has_node();
      ::pg_query::FuncCall* temp = node_.func_call_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.func_call_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FuncCall& Node::_internal_func_call() const {
  return _internal_has_func_call()
      ? *node_.func_call_
      : reinterpret_cast< ::pg_query::FuncCall&>(::pg_query::_FuncCall_default_instance_);
}
inline const ::pg_query::FuncCall& Node::func_call() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.func_call)
  return _internal_func_call();
}
inline ::pg_query::FuncCall* Node::unsafe_arena_release_func_call() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.func_call)
  if (_internal_has_func_call()) {
    clear_has_node();
    ::pg_query::FuncCall* temp = node_.func_call_;
    node_.func_call_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_func_call(::pg_query::FuncCall* func_call) {
  clear_node();
  if (func_call) {
    set_has_func_call();
    node_.func_call_ = func_call;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.func_call)
}
inline ::pg_query::FuncCall* Node::_internal_mutable_func_call() {
  if (!_internal_has_func_call()) {
    clear_node();
    set_has_func_call();
    node_.func_call_ = CreateMaybeMessage< ::pg_query::FuncCall >(GetArena());
  }
  return node_.func_call_;
}
inline ::pg_query::FuncCall* Node::mutable_func_call() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.func_call)
  return _internal_mutable_func_call();
}

// .pg_query.A_Star a_star = 172 [json_name = "A_Star"];
inline bool Node::_internal_has_a_star() const {
  return node_case() == kAStar;
}
inline bool Node::has_a_star() const {
  return _internal_has_a_star();
}
inline void Node::set_has_a_star() {
  _oneof_case_[0] = kAStar;
}
inline void Node::clear_a_star() {
  if (_internal_has_a_star()) {
    if (GetArena() == nullptr) {
      delete node_.a_star_;
    }
    clear_has_node();
  }
}
inline ::pg_query::A_Star* Node::release_a_star() {
  // @@protoc_insertion_point(field_release:pg_query.Node.a_star)
  if (_internal_has_a_star()) {
    clear_has_node();
      ::pg_query::A_Star* temp = node_.a_star_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.a_star_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::A_Star& Node::_internal_a_star() const {
  return _internal_has_a_star()
      ? *node_.a_star_
      : reinterpret_cast< ::pg_query::A_Star&>(::pg_query::_A_Star_default_instance_);
}
inline const ::pg_query::A_Star& Node::a_star() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.a_star)
  return _internal_a_star();
}
inline ::pg_query::A_Star* Node::unsafe_arena_release_a_star() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.a_star)
  if (_internal_has_a_star()) {
    clear_has_node();
    ::pg_query::A_Star* temp = node_.a_star_;
    node_.a_star_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_a_star(::pg_query::A_Star* a_star) {
  clear_node();
  if (a_star) {
    set_has_a_star();
    node_.a_star_ = a_star;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_star)
}
inline ::pg_query::A_Star* Node::_internal_mutable_a_star() {
  if (!_internal_has_a_star()) {
    clear_node();
    set_has_a_star();
    node_.a_star_ = CreateMaybeMessage< ::pg_query::A_Star >(GetArena());
  }
  return node_.a_star_;
}
inline ::pg_query::A_Star* Node::mutable_a_star() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.a_star)
  return _internal_mutable_a_star();
}

// .pg_query.A_Indices a_indices = 173 [json_name = "A_Indices"];
inline bool Node::_internal_has_a_indices() const {
  return node_case() == kAIndices;
}
inline bool Node::has_a_indices() const {
  return _internal_has_a_indices();
}
inline void Node::set_has_a_indices() {
  _oneof_case_[0] = kAIndices;
}
inline void Node::clear_a_indices() {
  if (_internal_has_a_indices()) {
    if (GetArena() == nullptr) {
      delete node_.a_indices_;
    }
    clear_has_node();
  }
}
inline ::pg_query::A_Indices* Node::release_a_indices() {
  // @@protoc_insertion_point(field_release:pg_query.Node.a_indices)
  if (_internal_has_a_indices()) {
    clear_has_node();
      ::pg_query::A_Indices* temp = node_.a_indices_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.a_indices_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::A_Indices& Node::_internal_a_indices() const {
  return _internal_has_a_indices()
      ? *node_.a_indices_
      : reinterpret_cast< ::pg_query::A_Indices&>(::pg_query::_A_Indices_default_instance_);
}
inline const ::pg_query::A_Indices& Node::a_indices() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.a_indices)
  return _internal_a_indices();
}
inline ::pg_query::A_Indices* Node::unsafe_arena_release_a_indices() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.a_indices)
  if (_internal_has_a_indices()) {
    clear_has_node();
    ::pg_query::A_Indices* temp = node_.a_indices_;
    node_.a_indices_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_a_indices(::pg_query::A_Indices* a_indices) {
  clear_node();
  if (a_indices) {
    set_has_a_indices();
    node_.a_indices_ = a_indices;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_indices)
}
inline ::pg_query::A_Indices* Node::_internal_mutable_a_indices() {
  if (!_internal_has_a_indices()) {
    clear_node();
    set_has_a_indices();
    node_.a_indices_ = CreateMaybeMessage< ::pg_query::A_Indices >(GetArena());
  }
  return node_.a_indices_;
}
inline ::pg_query::A_Indices* Node::mutable_a_indices() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.a_indices)
  return _internal_mutable_a_indices();
}

// .pg_query.A_Indirection a_indirection = 174 [json_name = "A_Indirection"];
inline bool Node::_internal_has_a_indirection() const {
  return node_case() == kAIndirection;
}
inline bool Node::has_a_indirection() const {
  return _internal_has_a_indirection();
}
inline void Node::set_has_a_indirection() {
  _oneof_case_[0] = kAIndirection;
}
inline void Node::clear_a_indirection() {
  if (_internal_has_a_indirection()) {
    if (GetArena() == nullptr) {
      delete node_.a_indirection_;
    }
    clear_has_node();
  }
}
inline ::pg_query::A_Indirection* Node::release_a_indirection() {
  // @@protoc_insertion_point(field_release:pg_query.Node.a_indirection)
  if (_internal_has_a_indirection()) {
    clear_has_node();
      ::pg_query::A_Indirection* temp = node_.a_indirection_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.a_indirection_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::A_Indirection& Node::_internal_a_indirection() const {
  return _internal_has_a_indirection()
      ? *node_.a_indirection_
      : reinterpret_cast< ::pg_query::A_Indirection&>(::pg_query::_A_Indirection_default_instance_);
}
inline const ::pg_query::A_Indirection& Node::a_indirection() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.a_indirection)
  return _internal_a_indirection();
}
inline ::pg_query::A_Indirection* Node::unsafe_arena_release_a_indirection() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.a_indirection)
  if (_internal_has_a_indirection()) {
    clear_has_node();
    ::pg_query::A_Indirection* temp = node_.a_indirection_;
    node_.a_indirection_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_a_indirection(::pg_query::A_Indirection* a_indirection) {
  clear_node();
  if (a_indirection) {
    set_has_a_indirection();
    node_.a_indirection_ = a_indirection;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_indirection)
}
inline ::pg_query::A_Indirection* Node::_internal_mutable_a_indirection() {
  if (!_internal_has_a_indirection()) {
    clear_node();
    set_has_a_indirection();
    node_.a_indirection_ = CreateMaybeMessage< ::pg_query::A_Indirection >(GetArena());
  }
  return node_.a_indirection_;
}
inline ::pg_query::A_Indirection* Node::mutable_a_indirection() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.a_indirection)
  return _internal_mutable_a_indirection();
}

// .pg_query.A_ArrayExpr a_array_expr = 175 [json_name = "A_ArrayExpr"];
inline bool Node::_internal_has_a_array_expr() const {
  return node_case() == kAArrayExpr;
}
inline bool Node::has_a_array_expr() const {
  return _internal_has_a_array_expr();
}
inline void Node::set_has_a_array_expr() {
  _oneof_case_[0] = kAArrayExpr;
}
inline void Node::clear_a_array_expr() {
  if (_internal_has_a_array_expr()) {
    if (GetArena() == nullptr) {
      delete node_.a_array_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::A_ArrayExpr* Node::release_a_array_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.a_array_expr)
  if (_internal_has_a_array_expr()) {
    clear_has_node();
      ::pg_query::A_ArrayExpr* temp = node_.a_array_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.a_array_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::A_ArrayExpr& Node::_internal_a_array_expr() const {
  return _internal_has_a_array_expr()
      ? *node_.a_array_expr_
      : reinterpret_cast< ::pg_query::A_ArrayExpr&>(::pg_query::_A_ArrayExpr_default_instance_);
}
inline const ::pg_query::A_ArrayExpr& Node::a_array_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.a_array_expr)
  return _internal_a_array_expr();
}
inline ::pg_query::A_ArrayExpr* Node::unsafe_arena_release_a_array_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.a_array_expr)
  if (_internal_has_a_array_expr()) {
    clear_has_node();
    ::pg_query::A_ArrayExpr* temp = node_.a_array_expr_;
    node_.a_array_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_a_array_expr(::pg_query::A_ArrayExpr* a_array_expr) {
  clear_node();
  if (a_array_expr) {
    set_has_a_array_expr();
    node_.a_array_expr_ = a_array_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_array_expr)
}
inline ::pg_query::A_ArrayExpr* Node::_internal_mutable_a_array_expr() {
  if (!_internal_has_a_array_expr()) {
    clear_node();
    set_has_a_array_expr();
    node_.a_array_expr_ = CreateMaybeMessage< ::pg_query::A_ArrayExpr >(GetArena());
  }
  return node_.a_array_expr_;
}
inline ::pg_query::A_ArrayExpr* Node::mutable_a_array_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.a_array_expr)
  return _internal_mutable_a_array_expr();
}

// .pg_query.ResTarget res_target = 176 [json_name = "ResTarget"];
inline bool Node::_internal_has_res_target() const {
  return node_case() == kResTarget;
}
inline bool Node::has_res_target() const {
  return _internal_has_res_target();
}
inline void Node::set_has_res_target() {
  _oneof_case_[0] = kResTarget;
}
inline void Node::clear_res_target() {
  if (_internal_has_res_target()) {
    if (GetArena() == nullptr) {
      delete node_.res_target_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ResTarget* Node::release_res_target() {
  // @@protoc_insertion_point(field_release:pg_query.Node.res_target)
  if (_internal_has_res_target()) {
    clear_has_node();
      ::pg_query::ResTarget* temp = node_.res_target_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.res_target_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ResTarget& Node::_internal_res_target() const {
  return _internal_has_res_target()
      ? *node_.res_target_
      : reinterpret_cast< ::pg_query::ResTarget&>(::pg_query::_ResTarget_default_instance_);
}
inline const ::pg_query::ResTarget& Node::res_target() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.res_target)
  return _internal_res_target();
}
inline ::pg_query::ResTarget* Node::unsafe_arena_release_res_target() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.res_target)
  if (_internal_has_res_target()) {
    clear_has_node();
    ::pg_query::ResTarget* temp = node_.res_target_;
    node_.res_target_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_res_target(::pg_query::ResTarget* res_target) {
  clear_node();
  if (res_target) {
    set_has_res_target();
    node_.res_target_ = res_target;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.res_target)
}
inline ::pg_query::ResTarget* Node::_internal_mutable_res_target() {
  if (!_internal_has_res_target()) {
    clear_node();
    set_has_res_target();
    node_.res_target_ = CreateMaybeMessage< ::pg_query::ResTarget >(GetArena());
  }
  return node_.res_target_;
}
inline ::pg_query::ResTarget* Node::mutable_res_target() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.res_target)
  return _internal_mutable_res_target();
}

// .pg_query.MultiAssignRef multi_assign_ref = 177 [json_name = "MultiAssignRef"];
inline bool Node::_internal_has_multi_assign_ref() const {
  return node_case() == kMultiAssignRef;
}
inline bool Node::has_multi_assign_ref() const {
  return _internal_has_multi_assign_ref();
}
inline void Node::set_has_multi_assign_ref() {
  _oneof_case_[0] = kMultiAssignRef;
}
inline void Node::clear_multi_assign_ref() {
  if (_internal_has_multi_assign_ref()) {
    if (GetArena() == nullptr) {
      delete node_.multi_assign_ref_;
    }
    clear_has_node();
  }
}
inline ::pg_query::MultiAssignRef* Node::release_multi_assign_ref() {
  // @@protoc_insertion_point(field_release:pg_query.Node.multi_assign_ref)
  if (_internal_has_multi_assign_ref()) {
    clear_has_node();
      ::pg_query::MultiAssignRef* temp = node_.multi_assign_ref_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.multi_assign_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::MultiAssignRef& Node::_internal_multi_assign_ref() const {
  return _internal_has_multi_assign_ref()
      ? *node_.multi_assign_ref_
      : reinterpret_cast< ::pg_query::MultiAssignRef&>(::pg_query::_MultiAssignRef_default_instance_);
}
inline const ::pg_query::MultiAssignRef& Node::multi_assign_ref() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.multi_assign_ref)
  return _internal_multi_assign_ref();
}
inline ::pg_query::MultiAssignRef* Node::unsafe_arena_release_multi_assign_ref() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.multi_assign_ref)
  if (_internal_has_multi_assign_ref()) {
    clear_has_node();
    ::pg_query::MultiAssignRef* temp = node_.multi_assign_ref_;
    node_.multi_assign_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_multi_assign_ref(::pg_query::MultiAssignRef* multi_assign_ref) {
  clear_node();
  if (multi_assign_ref) {
    set_has_multi_assign_ref();
    node_.multi_assign_ref_ = multi_assign_ref;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.multi_assign_ref)
}
inline ::pg_query::MultiAssignRef* Node::_internal_mutable_multi_assign_ref() {
  if (!_internal_has_multi_assign_ref()) {
    clear_node();
    set_has_multi_assign_ref();
    node_.multi_assign_ref_ = CreateMaybeMessage< ::pg_query::MultiAssignRef >(GetArena());
  }
  return node_.multi_assign_ref_;
}
inline ::pg_query::MultiAssignRef* Node::mutable_multi_assign_ref() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.multi_assign_ref)
  return _internal_mutable_multi_assign_ref();
}

// .pg_query.TypeCast type_cast = 178 [json_name = "TypeCast"];
inline bool Node::_internal_has_type_cast() const {
  return node_case() == kTypeCast;
}
inline bool Node::has_type_cast() const {
  return _internal_has_type_cast();
}
inline void Node::set_has_type_cast() {
  _oneof_case_[0] = kTypeCast;
}
inline void Node::clear_type_cast() {
  if (_internal_has_type_cast()) {
    if (GetArena() == nullptr) {
      delete node_.type_cast_;
    }
    clear_has_node();
  }
}
inline ::pg_query::TypeCast* Node::release_type_cast() {
  // @@protoc_insertion_point(field_release:pg_query.Node.type_cast)
  if (_internal_has_type_cast()) {
    clear_has_node();
      ::pg_query::TypeCast* temp = node_.type_cast_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.type_cast_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TypeCast& Node::_internal_type_cast() const {
  return _internal_has_type_cast()
      ? *node_.type_cast_
      : reinterpret_cast< ::pg_query::TypeCast&>(::pg_query::_TypeCast_default_instance_);
}
inline const ::pg_query::TypeCast& Node::type_cast() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.type_cast)
  return _internal_type_cast();
}
inline ::pg_query::TypeCast* Node::unsafe_arena_release_type_cast() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.type_cast)
  if (_internal_has_type_cast()) {
    clear_has_node();
    ::pg_query::TypeCast* temp = node_.type_cast_;
    node_.type_cast_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_type_cast(::pg_query::TypeCast* type_cast) {
  clear_node();
  if (type_cast) {
    set_has_type_cast();
    node_.type_cast_ = type_cast;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.type_cast)
}
inline ::pg_query::TypeCast* Node::_internal_mutable_type_cast() {
  if (!_internal_has_type_cast()) {
    clear_node();
    set_has_type_cast();
    node_.type_cast_ = CreateMaybeMessage< ::pg_query::TypeCast >(GetArena());
  }
  return node_.type_cast_;
}
inline ::pg_query::TypeCast* Node::mutable_type_cast() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.type_cast)
  return _internal_mutable_type_cast();
}

// .pg_query.CollateClause collate_clause = 179 [json_name = "CollateClause"];
inline bool Node::_internal_has_collate_clause() const {
  return node_case() == kCollateClause;
}
inline bool Node::has_collate_clause() const {
  return _internal_has_collate_clause();
}
inline void Node::set_has_collate_clause() {
  _oneof_case_[0] = kCollateClause;
}
inline void Node::clear_collate_clause() {
  if (_internal_has_collate_clause()) {
    if (GetArena() == nullptr) {
      delete node_.collate_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CollateClause* Node::release_collate_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.collate_clause)
  if (_internal_has_collate_clause()) {
    clear_has_node();
      ::pg_query::CollateClause* temp = node_.collate_clause_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.collate_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CollateClause& Node::_internal_collate_clause() const {
  return _internal_has_collate_clause()
      ? *node_.collate_clause_
      : reinterpret_cast< ::pg_query::CollateClause&>(::pg_query::_CollateClause_default_instance_);
}
inline const ::pg_query::CollateClause& Node::collate_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.collate_clause)
  return _internal_collate_clause();
}
inline ::pg_query::CollateClause* Node::unsafe_arena_release_collate_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.collate_clause)
  if (_internal_has_collate_clause()) {
    clear_has_node();
    ::pg_query::CollateClause* temp = node_.collate_clause_;
    node_.collate_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_collate_clause(::pg_query::CollateClause* collate_clause) {
  clear_node();
  if (collate_clause) {
    set_has_collate_clause();
    node_.collate_clause_ = collate_clause;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.collate_clause)
}
inline ::pg_query::CollateClause* Node::_internal_mutable_collate_clause() {
  if (!_internal_has_collate_clause()) {
    clear_node();
    set_has_collate_clause();
    node_.collate_clause_ = CreateMaybeMessage< ::pg_query::CollateClause >(GetArena());
  }
  return node_.collate_clause_;
}
inline ::pg_query::CollateClause* Node::mutable_collate_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.collate_clause)
  return _internal_mutable_collate_clause();
}

// .pg_query.SortBy sort_by = 180 [json_name = "SortBy"];
inline bool Node::_internal_has_sort_by() const {
  return node_case() == kSortBy;
}
inline bool Node::has_sort_by() const {
  return _internal_has_sort_by();
}
inline void Node::set_has_sort_by() {
  _oneof_case_[0] = kSortBy;
}
inline void Node::clear_sort_by() {
  if (_internal_has_sort_by()) {
    if (GetArena() == nullptr) {
      delete node_.sort_by_;
    }
    clear_has_node();
  }
}
inline ::pg_query::SortBy* Node::release_sort_by() {
  // @@protoc_insertion_point(field_release:pg_query.Node.sort_by)
  if (_internal_has_sort_by()) {
    clear_has_node();
      ::pg_query::SortBy* temp = node_.sort_by_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.sort_by_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SortBy& Node::_internal_sort_by() const {
  return _internal_has_sort_by()
      ? *node_.sort_by_
      : reinterpret_cast< ::pg_query::SortBy&>(::pg_query::_SortBy_default_instance_);
}
inline const ::pg_query::SortBy& Node::sort_by() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.sort_by)
  return _internal_sort_by();
}
inline ::pg_query::SortBy* Node::unsafe_arena_release_sort_by() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.sort_by)
  if (_internal_has_sort_by()) {
    clear_has_node();
    ::pg_query::SortBy* temp = node_.sort_by_;
    node_.sort_by_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_sort_by(::pg_query::SortBy* sort_by) {
  clear_node();
  if (sort_by) {
    set_has_sort_by();
    node_.sort_by_ = sort_by;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sort_by)
}
inline ::pg_query::SortBy* Node::_internal_mutable_sort_by() {
  if (!_internal_has_sort_by()) {
    clear_node();
    set_has_sort_by();
    node_.sort_by_ = CreateMaybeMessage< ::pg_query::SortBy >(GetArena());
  }
  return node_.sort_by_;
}
inline ::pg_query::SortBy* Node::mutable_sort_by() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.sort_by)
  return _internal_mutable_sort_by();
}

// .pg_query.WindowDef window_def = 181 [json_name = "WindowDef"];
inline bool Node::_internal_has_window_def() const {
  return node_case() == kWindowDef;
}
inline bool Node::has_window_def() const {
  return _internal_has_window_def();
}
inline void Node::set_has_window_def() {
  _oneof_case_[0] = kWindowDef;
}
inline void Node::clear_window_def() {
  if (_internal_has_window_def()) {
    if (GetArena() == nullptr) {
      delete node_.window_def_;
    }
    clear_has_node();
  }
}
inline ::pg_query::WindowDef* Node::release_window_def() {
  // @@protoc_insertion_point(field_release:pg_query.Node.window_def)
  if (_internal_has_window_def()) {
    clear_has_node();
      ::pg_query::WindowDef* temp = node_.window_def_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.window_def_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::WindowDef& Node::_internal_window_def() const {
  return _internal_has_window_def()
      ? *node_.window_def_
      : reinterpret_cast< ::pg_query::WindowDef&>(::pg_query::_WindowDef_default_instance_);
}
inline const ::pg_query::WindowDef& Node::window_def() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.window_def)
  return _internal_window_def();
}
inline ::pg_query::WindowDef* Node::unsafe_arena_release_window_def() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.window_def)
  if (_internal_has_window_def()) {
    clear_has_node();
    ::pg_query::WindowDef* temp = node_.window_def_;
    node_.window_def_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_window_def(::pg_query::WindowDef* window_def) {
  clear_node();
  if (window_def) {
    set_has_window_def();
    node_.window_def_ = window_def;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.window_def)
}
inline ::pg_query::WindowDef* Node::_internal_mutable_window_def() {
  if (!_internal_has_window_def()) {
    clear_node();
    set_has_window_def();
    node_.window_def_ = CreateMaybeMessage< ::pg_query::WindowDef >(GetArena());
  }
  return node_.window_def_;
}
inline ::pg_query::WindowDef* Node::mutable_window_def() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.window_def)
  return _internal_mutable_window_def();
}

// .pg_query.RangeSubselect range_subselect = 182 [json_name = "RangeSubselect"];
inline bool Node::_internal_has_range_subselect() const {
  return node_case() == kRangeSubselect;
}
inline bool Node::has_range_subselect() const {
  return _internal_has_range_subselect();
}
inline void Node::set_has_range_subselect() {
  _oneof_case_[0] = kRangeSubselect;
}
inline void Node::clear_range_subselect() {
  if (_internal_has_range_subselect()) {
    if (GetArena() == nullptr) {
      delete node_.range_subselect_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RangeSubselect* Node::release_range_subselect() {
  // @@protoc_insertion_point(field_release:pg_query.Node.range_subselect)
  if (_internal_has_range_subselect()) {
    clear_has_node();
      ::pg_query::RangeSubselect* temp = node_.range_subselect_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.range_subselect_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeSubselect& Node::_internal_range_subselect() const {
  return _internal_has_range_subselect()
      ? *node_.range_subselect_
      : reinterpret_cast< ::pg_query::RangeSubselect&>(::pg_query::_RangeSubselect_default_instance_);
}
inline const ::pg_query::RangeSubselect& Node::range_subselect() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.range_subselect)
  return _internal_range_subselect();
}
inline ::pg_query::RangeSubselect* Node::unsafe_arena_release_range_subselect() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_subselect)
  if (_internal_has_range_subselect()) {
    clear_has_node();
    ::pg_query::RangeSubselect* temp = node_.range_subselect_;
    node_.range_subselect_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_subselect(::pg_query::RangeSubselect* range_subselect) {
  clear_node();
  if (range_subselect) {
    set_has_range_subselect();
    node_.range_subselect_ = range_subselect;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_subselect)
}
inline ::pg_query::RangeSubselect* Node::_internal_mutable_range_subselect() {
  if (!_internal_has_range_subselect()) {
    clear_node();
    set_has_range_subselect();
    node_.range_subselect_ = CreateMaybeMessage< ::pg_query::RangeSubselect >(GetArena());
  }
  return node_.range_subselect_;
}
inline ::pg_query::RangeSubselect* Node::mutable_range_subselect() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_subselect)
  return _internal_mutable_range_subselect();
}

// .pg_query.RangeFunction range_function = 183 [json_name = "RangeFunction"];
inline bool Node::_internal_has_range_function() const {
  return node_case() == kRangeFunction;
}
inline bool Node::has_range_function() const {
  return _internal_has_range_function();
}
inline void Node::set_has_range_function() {
  _oneof_case_[0] = kRangeFunction;
}
inline void Node::clear_range_function() {
  if (_internal_has_range_function()) {
    if (GetArena() == nullptr) {
      delete node_.range_function_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RangeFunction* Node::release_range_function() {
  // @@protoc_insertion_point(field_release:pg_query.Node.range_function)
  if (_internal_has_range_function()) {
    clear_has_node();
      ::pg_query::RangeFunction* temp = node_.range_function_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.range_function_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeFunction& Node::_internal_range_function() const {
  return _internal_has_range_function()
      ? *node_.range_function_
      : reinterpret_cast< ::pg_query::RangeFunction&>(::pg_query::_RangeFunction_default_instance_);
}
inline const ::pg_query::RangeFunction& Node::range_function() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.range_function)
  return _internal_range_function();
}
inline ::pg_query::RangeFunction* Node::unsafe_arena_release_range_function() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_function)
  if (_internal_has_range_function()) {
    clear_has_node();
    ::pg_query::RangeFunction* temp = node_.range_function_;
    node_.range_function_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_function(::pg_query::RangeFunction* range_function) {
  clear_node();
  if (range_function) {
    set_has_range_function();
    node_.range_function_ = range_function;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_function)
}
inline ::pg_query::RangeFunction* Node::_internal_mutable_range_function() {
  if (!_internal_has_range_function()) {
    clear_node();
    set_has_range_function();
    node_.range_function_ = CreateMaybeMessage< ::pg_query::RangeFunction >(GetArena());
  }
  return node_.range_function_;
}
inline ::pg_query::RangeFunction* Node::mutable_range_function() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_function)
  return _internal_mutable_range_function();
}

// .pg_query.RangeTableSample range_table_sample = 184 [json_name = "RangeTableSample"];
inline bool Node::_internal_has_range_table_sample() const {
  return node_case() == kRangeTableSample;
}
inline bool Node::has_range_table_sample() const {
  return _internal_has_range_table_sample();
}
inline void Node::set_has_range_table_sample() {
  _oneof_case_[0] = kRangeTableSample;
}
inline void Node::clear_range_table_sample() {
  if (_internal_has_range_table_sample()) {
    if (GetArena() == nullptr) {
      delete node_.range_table_sample_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RangeTableSample* Node::release_range_table_sample() {
  // @@protoc_insertion_point(field_release:pg_query.Node.range_table_sample)
  if (_internal_has_range_table_sample()) {
    clear_has_node();
      ::pg_query::RangeTableSample* temp = node_.range_table_sample_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.range_table_sample_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeTableSample& Node::_internal_range_table_sample() const {
  return _internal_has_range_table_sample()
      ? *node_.range_table_sample_
      : reinterpret_cast< ::pg_query::RangeTableSample&>(::pg_query::_RangeTableSample_default_instance_);
}
inline const ::pg_query::RangeTableSample& Node::range_table_sample() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.range_table_sample)
  return _internal_range_table_sample();
}
inline ::pg_query::RangeTableSample* Node::unsafe_arena_release_range_table_sample() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_table_sample)
  if (_internal_has_range_table_sample()) {
    clear_has_node();
    ::pg_query::RangeTableSample* temp = node_.range_table_sample_;
    node_.range_table_sample_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_table_sample(::pg_query::RangeTableSample* range_table_sample) {
  clear_node();
  if (range_table_sample) {
    set_has_range_table_sample();
    node_.range_table_sample_ = range_table_sample;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_table_sample)
}
inline ::pg_query::RangeTableSample* Node::_internal_mutable_range_table_sample() {
  if (!_internal_has_range_table_sample()) {
    clear_node();
    set_has_range_table_sample();
    node_.range_table_sample_ = CreateMaybeMessage< ::pg_query::RangeTableSample >(GetArena());
  }
  return node_.range_table_sample_;
}
inline ::pg_query::RangeTableSample* Node::mutable_range_table_sample() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_table_sample)
  return _internal_mutable_range_table_sample();
}

// .pg_query.RangeTableFunc range_table_func = 185 [json_name = "RangeTableFunc"];
inline bool Node::_internal_has_range_table_func() const {
  return node_case() == kRangeTableFunc;
}
inline bool Node::has_range_table_func() const {
  return _internal_has_range_table_func();
}
inline void Node::set_has_range_table_func() {
  _oneof_case_[0] = kRangeTableFunc;
}
inline void Node::clear_range_table_func() {
  if (_internal_has_range_table_func()) {
    if (GetArena() == nullptr) {
      delete node_.range_table_func_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RangeTableFunc* Node::release_range_table_func() {
  // @@protoc_insertion_point(field_release:pg_query.Node.range_table_func)
  if (_internal_has_range_table_func()) {
    clear_has_node();
      ::pg_query::RangeTableFunc* temp = node_.range_table_func_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.range_table_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeTableFunc& Node::_internal_range_table_func() const {
  return _internal_has_range_table_func()
      ? *node_.range_table_func_
      : reinterpret_cast< ::pg_query::RangeTableFunc&>(::pg_query::_RangeTableFunc_default_instance_);
}
inline const ::pg_query::RangeTableFunc& Node::range_table_func() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.range_table_func)
  return _internal_range_table_func();
}
inline ::pg_query::RangeTableFunc* Node::unsafe_arena_release_range_table_func() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_table_func)
  if (_internal_has_range_table_func()) {
    clear_has_node();
    ::pg_query::RangeTableFunc* temp = node_.range_table_func_;
    node_.range_table_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_table_func(::pg_query::RangeTableFunc* range_table_func) {
  clear_node();
  if (range_table_func) {
    set_has_range_table_func();
    node_.range_table_func_ = range_table_func;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_table_func)
}
inline ::pg_query::RangeTableFunc* Node::_internal_mutable_range_table_func() {
  if (!_internal_has_range_table_func()) {
    clear_node();
    set_has_range_table_func();
    node_.range_table_func_ = CreateMaybeMessage< ::pg_query::RangeTableFunc >(GetArena());
  }
  return node_.range_table_func_;
}
inline ::pg_query::RangeTableFunc* Node::mutable_range_table_func() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_table_func)
  return _internal_mutable_range_table_func();
}

// .pg_query.RangeTableFuncCol range_table_func_col = 186 [json_name = "RangeTableFuncCol"];
inline bool Node::_internal_has_range_table_func_col() const {
  return node_case() == kRangeTableFuncCol;
}
inline bool Node::has_range_table_func_col() const {
  return _internal_has_range_table_func_col();
}
inline void Node::set_has_range_table_func_col() {
  _oneof_case_[0] = kRangeTableFuncCol;
}
inline void Node::clear_range_table_func_col() {
  if (_internal_has_range_table_func_col()) {
    if (GetArena() == nullptr) {
      delete node_.range_table_func_col_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RangeTableFuncCol* Node::release_range_table_func_col() {
  // @@protoc_insertion_point(field_release:pg_query.Node.range_table_func_col)
  if (_internal_has_range_table_func_col()) {
    clear_has_node();
      ::pg_query::RangeTableFuncCol* temp = node_.range_table_func_col_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.range_table_func_col_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeTableFuncCol& Node::_internal_range_table_func_col() const {
  return _internal_has_range_table_func_col()
      ? *node_.range_table_func_col_
      : reinterpret_cast< ::pg_query::RangeTableFuncCol&>(::pg_query::_RangeTableFuncCol_default_instance_);
}
inline const ::pg_query::RangeTableFuncCol& Node::range_table_func_col() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.range_table_func_col)
  return _internal_range_table_func_col();
}
inline ::pg_query::RangeTableFuncCol* Node::unsafe_arena_release_range_table_func_col() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_table_func_col)
  if (_internal_has_range_table_func_col()) {
    clear_has_node();
    ::pg_query::RangeTableFuncCol* temp = node_.range_table_func_col_;
    node_.range_table_func_col_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_table_func_col(::pg_query::RangeTableFuncCol* range_table_func_col) {
  clear_node();
  if (range_table_func_col) {
    set_has_range_table_func_col();
    node_.range_table_func_col_ = range_table_func_col;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_table_func_col)
}
inline ::pg_query::RangeTableFuncCol* Node::_internal_mutable_range_table_func_col() {
  if (!_internal_has_range_table_func_col()) {
    clear_node();
    set_has_range_table_func_col();
    node_.range_table_func_col_ = CreateMaybeMessage< ::pg_query::RangeTableFuncCol >(GetArena());
  }
  return node_.range_table_func_col_;
}
inline ::pg_query::RangeTableFuncCol* Node::mutable_range_table_func_col() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_table_func_col)
  return _internal_mutable_range_table_func_col();
}

// .pg_query.TypeName type_name = 187 [json_name = "TypeName"];
inline bool Node::_internal_has_type_name() const {
  return node_case() == kTypeName;
}
inline bool Node::has_type_name() const {
  return _internal_has_type_name();
}
inline void Node::set_has_type_name() {
  _oneof_case_[0] = kTypeName;
}
inline void Node::clear_type_name() {
  if (_internal_has_type_name()) {
    if (GetArena() == nullptr) {
      delete node_.type_name_;
    }
    clear_has_node();
  }
}
inline ::pg_query::TypeName* Node::release_type_name() {
  // @@protoc_insertion_point(field_release:pg_query.Node.type_name)
  if (_internal_has_type_name()) {
    clear_has_node();
      ::pg_query::TypeName* temp = node_.type_name_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.type_name_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TypeName& Node::_internal_type_name() const {
  return _internal_has_type_name()
      ? *node_.type_name_
      : reinterpret_cast< ::pg_query::TypeName&>(::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& Node::type_name() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.type_name)
  return _internal_type_name();
}
inline ::pg_query::TypeName* Node::unsafe_arena_release_type_name() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.type_name)
  if (_internal_has_type_name()) {
    clear_has_node();
    ::pg_query::TypeName* temp = node_.type_name_;
    node_.type_name_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_type_name(::pg_query::TypeName* type_name) {
  clear_node();
  if (type_name) {
    set_has_type_name();
    node_.type_name_ = type_name;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.type_name)
}
inline ::pg_query::TypeName* Node::_internal_mutable_type_name() {
  if (!_internal_has_type_name()) {
    clear_node();
    set_has_type_name();
    node_.type_name_ = CreateMaybeMessage< ::pg_query::TypeName >(GetArena());
  }
  return node_.type_name_;
}
inline ::pg_query::TypeName* Node::mutable_type_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.type_name)
  return _internal_mutable_type_name();
}

// .pg_query.ColumnDef column_def = 188 [json_name = "ColumnDef"];
inline bool Node::_internal_has_column_def() const {
  return node_case() == kColumnDef;
}
inline bool Node::has_column_def() const {
  return _internal_has_column_def();
}
inline void Node::set_has_column_def() {
  _oneof_case_[0] = kColumnDef;
}
inline void Node::clear_column_def() {
  if (_internal_has_column_def()) {
    if (GetArena() == nullptr) {
      delete node_.column_def_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ColumnDef* Node::release_column_def() {
  // @@protoc_insertion_point(field_release:pg_query.Node.column_def)
  if (_internal_has_column_def()) {
    clear_has_node();
      ::pg_query::ColumnDef* temp = node_.column_def_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.column_def_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ColumnDef& Node::_internal_column_def() const {
  return _internal_has_column_def()
      ? *node_.column_def_
      : reinterpret_cast< ::pg_query::ColumnDef&>(::pg_query::_ColumnDef_default_instance_);
}
inline const ::pg_query::ColumnDef& Node::column_def() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.column_def)
  return _internal_column_def();
}
inline ::pg_query::ColumnDef* Node::unsafe_arena_release_column_def() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.column_def)
  if (_internal_has_column_def()) {
    clear_has_node();
    ::pg_query::ColumnDef* temp = node_.column_def_;
    node_.column_def_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_column_def(::pg_query::ColumnDef* column_def) {
  clear_node();
  if (column_def) {
    set_has_column_def();
    node_.column_def_ = column_def;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.column_def)
}
inline ::pg_query::ColumnDef* Node::_internal_mutable_column_def() {
  if (!_internal_has_column_def()) {
    clear_node();
    set_has_column_def();
    node_.column_def_ = CreateMaybeMessage< ::pg_query::ColumnDef >(GetArena());
  }
  return node_.column_def_;
}
inline ::pg_query::ColumnDef* Node::mutable_column_def() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.column_def)
  return _internal_mutable_column_def();
}

// .pg_query.IndexElem index_elem = 189 [json_name = "IndexElem"];
inline bool Node::_internal_has_index_elem() const {
  return node_case() == kIndexElem;
}
inline bool Node::has_index_elem() const {
  return _internal_has_index_elem();
}
inline void Node::set_has_index_elem() {
  _oneof_case_[0] = kIndexElem;
}
inline void Node::clear_index_elem() {
  if (_internal_has_index_elem()) {
    if (GetArena() == nullptr) {
      delete node_.index_elem_;
    }
    clear_has_node();
  }
}
inline ::pg_query::IndexElem* Node::release_index_elem() {
  // @@protoc_insertion_point(field_release:pg_query.Node.index_elem)
  if (_internal_has_index_elem()) {
    clear_has_node();
      ::pg_query::IndexElem* temp = node_.index_elem_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.index_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::IndexElem& Node::_internal_index_elem() const {
  return _internal_has_index_elem()
      ? *node_.index_elem_
      : reinterpret_cast< ::pg_query::IndexElem&>(::pg_query::_IndexElem_default_instance_);
}
inline const ::pg_query::IndexElem& Node::index_elem() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.index_elem)
  return _internal_index_elem();
}
inline ::pg_query::IndexElem* Node::unsafe_arena_release_index_elem() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.index_elem)
  if (_internal_has_index_elem()) {
    clear_has_node();
    ::pg_query::IndexElem* temp = node_.index_elem_;
    node_.index_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_index_elem(::pg_query::IndexElem* index_elem) {
  clear_node();
  if (index_elem) {
    set_has_index_elem();
    node_.index_elem_ = index_elem;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.index_elem)
}
inline ::pg_query::IndexElem* Node::_internal_mutable_index_elem() {
  if (!_internal_has_index_elem()) {
    clear_node();
    set_has_index_elem();
    node_.index_elem_ = CreateMaybeMessage< ::pg_query::IndexElem >(GetArena());
  }
  return node_.index_elem_;
}
inline ::pg_query::IndexElem* Node::mutable_index_elem() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.index_elem)
  return _internal_mutable_index_elem();
}

// .pg_query.Constraint constraint = 190 [json_name = "Constraint"];
inline bool Node::_internal_has_constraint() const {
  return node_case() == kConstraint;
}
inline bool Node::has_constraint() const {
  return _internal_has_constraint();
}
inline void Node::set_has_constraint() {
  _oneof_case_[0] = kConstraint;
}
inline void Node::clear_constraint() {
  if (_internal_has_constraint()) {
    if (GetArena() == nullptr) {
      delete node_.constraint_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Constraint* Node::release_constraint() {
  // @@protoc_insertion_point(field_release:pg_query.Node.constraint)
  if (_internal_has_constraint()) {
    clear_has_node();
      ::pg_query::Constraint* temp = node_.constraint_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Constraint& Node::_internal_constraint() const {
  return _internal_has_constraint()
      ? *node_.constraint_
      : reinterpret_cast< ::pg_query::Constraint&>(::pg_query::_Constraint_default_instance_);
}
inline const ::pg_query::Constraint& Node::constraint() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.constraint)
  return _internal_constraint();
}
inline ::pg_query::Constraint* Node::unsafe_arena_release_constraint() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.constraint)
  if (_internal_has_constraint()) {
    clear_has_node();
    ::pg_query::Constraint* temp = node_.constraint_;
    node_.constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_constraint(::pg_query::Constraint* constraint) {
  clear_node();
  if (constraint) {
    set_has_constraint();
    node_.constraint_ = constraint;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.constraint)
}
inline ::pg_query::Constraint* Node::_internal_mutable_constraint() {
  if (!_internal_has_constraint()) {
    clear_node();
    set_has_constraint();
    node_.constraint_ = CreateMaybeMessage< ::pg_query::Constraint >(GetArena());
  }
  return node_.constraint_;
}
inline ::pg_query::Constraint* Node::mutable_constraint() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.constraint)
  return _internal_mutable_constraint();
}

// .pg_query.DefElem def_elem = 191 [json_name = "DefElem"];
inline bool Node::_internal_has_def_elem() const {
  return node_case() == kDefElem;
}
inline bool Node::has_def_elem() const {
  return _internal_has_def_elem();
}
inline void Node::set_has_def_elem() {
  _oneof_case_[0] = kDefElem;
}
inline void Node::clear_def_elem() {
  if (_internal_has_def_elem()) {
    if (GetArena() == nullptr) {
      delete node_.def_elem_;
    }
    clear_has_node();
  }
}
inline ::pg_query::DefElem* Node::release_def_elem() {
  // @@protoc_insertion_point(field_release:pg_query.Node.def_elem)
  if (_internal_has_def_elem()) {
    clear_has_node();
      ::pg_query::DefElem* temp = node_.def_elem_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.def_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DefElem& Node::_internal_def_elem() const {
  return _internal_has_def_elem()
      ? *node_.def_elem_
      : reinterpret_cast< ::pg_query::DefElem&>(::pg_query::_DefElem_default_instance_);
}
inline const ::pg_query::DefElem& Node::def_elem() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.def_elem)
  return _internal_def_elem();
}
inline ::pg_query::DefElem* Node::unsafe_arena_release_def_elem() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.def_elem)
  if (_internal_has_def_elem()) {
    clear_has_node();
    ::pg_query::DefElem* temp = node_.def_elem_;
    node_.def_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_def_elem(::pg_query::DefElem* def_elem) {
  clear_node();
  if (def_elem) {
    set_has_def_elem();
    node_.def_elem_ = def_elem;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.def_elem)
}
inline ::pg_query::DefElem* Node::_internal_mutable_def_elem() {
  if (!_internal_has_def_elem()) {
    clear_node();
    set_has_def_elem();
    node_.def_elem_ = CreateMaybeMessage< ::pg_query::DefElem >(GetArena());
  }
  return node_.def_elem_;
}
inline ::pg_query::DefElem* Node::mutable_def_elem() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.def_elem)
  return _internal_mutable_def_elem();
}

// .pg_query.RangeTblEntry range_tbl_entry = 192 [json_name = "RangeTblEntry"];
inline bool Node::_internal_has_range_tbl_entry() const {
  return node_case() == kRangeTblEntry;
}
inline bool Node::has_range_tbl_entry() const {
  return _internal_has_range_tbl_entry();
}
inline void Node::set_has_range_tbl_entry() {
  _oneof_case_[0] = kRangeTblEntry;
}
inline void Node::clear_range_tbl_entry() {
  if (_internal_has_range_tbl_entry()) {
    if (GetArena() == nullptr) {
      delete node_.range_tbl_entry_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RangeTblEntry* Node::release_range_tbl_entry() {
  // @@protoc_insertion_point(field_release:pg_query.Node.range_tbl_entry)
  if (_internal_has_range_tbl_entry()) {
    clear_has_node();
      ::pg_query::RangeTblEntry* temp = node_.range_tbl_entry_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.range_tbl_entry_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeTblEntry& Node::_internal_range_tbl_entry() const {
  return _internal_has_range_tbl_entry()
      ? *node_.range_tbl_entry_
      : reinterpret_cast< ::pg_query::RangeTblEntry&>(::pg_query::_RangeTblEntry_default_instance_);
}
inline const ::pg_query::RangeTblEntry& Node::range_tbl_entry() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.range_tbl_entry)
  return _internal_range_tbl_entry();
}
inline ::pg_query::RangeTblEntry* Node::unsafe_arena_release_range_tbl_entry() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_tbl_entry)
  if (_internal_has_range_tbl_entry()) {
    clear_has_node();
    ::pg_query::RangeTblEntry* temp = node_.range_tbl_entry_;
    node_.range_tbl_entry_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_tbl_entry(::pg_query::RangeTblEntry* range_tbl_entry) {
  clear_node();
  if (range_tbl_entry) {
    set_has_range_tbl_entry();
    node_.range_tbl_entry_ = range_tbl_entry;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_tbl_entry)
}
inline ::pg_query::RangeTblEntry* Node::_internal_mutable_range_tbl_entry() {
  if (!_internal_has_range_tbl_entry()) {
    clear_node();
    set_has_range_tbl_entry();
    node_.range_tbl_entry_ = CreateMaybeMessage< ::pg_query::RangeTblEntry >(GetArena());
  }
  return node_.range_tbl_entry_;
}
inline ::pg_query::RangeTblEntry* Node::mutable_range_tbl_entry() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_tbl_entry)
  return _internal_mutable_range_tbl_entry();
}

// .pg_query.RangeTblFunction range_tbl_function = 193 [json_name = "RangeTblFunction"];
inline bool Node::_internal_has_range_tbl_function() const {
  return node_case() == kRangeTblFunction;
}
inline bool Node::has_range_tbl_function() const {
  return _internal_has_range_tbl_function();
}
inline void Node::set_has_range_tbl_function() {
  _oneof_case_[0] = kRangeTblFunction;
}
inline void Node::clear_range_tbl_function() {
  if (_internal_has_range_tbl_function()) {
    if (GetArena() == nullptr) {
      delete node_.range_tbl_function_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RangeTblFunction* Node::release_range_tbl_function() {
  // @@protoc_insertion_point(field_release:pg_query.Node.range_tbl_function)
  if (_internal_has_range_tbl_function()) {
    clear_has_node();
      ::pg_query::RangeTblFunction* temp = node_.range_tbl_function_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.range_tbl_function_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeTblFunction& Node::_internal_range_tbl_function() const {
  return _internal_has_range_tbl_function()
      ? *node_.range_tbl_function_
      : reinterpret_cast< ::pg_query::RangeTblFunction&>(::pg_query::_RangeTblFunction_default_instance_);
}
inline const ::pg_query::RangeTblFunction& Node::range_tbl_function() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.range_tbl_function)
  return _internal_range_tbl_function();
}
inline ::pg_query::RangeTblFunction* Node::unsafe_arena_release_range_tbl_function() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_tbl_function)
  if (_internal_has_range_tbl_function()) {
    clear_has_node();
    ::pg_query::RangeTblFunction* temp = node_.range_tbl_function_;
    node_.range_tbl_function_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_tbl_function(::pg_query::RangeTblFunction* range_tbl_function) {
  clear_node();
  if (range_tbl_function) {
    set_has_range_tbl_function();
    node_.range_tbl_function_ = range_tbl_function;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_tbl_function)
}
inline ::pg_query::RangeTblFunction* Node::_internal_mutable_range_tbl_function() {
  if (!_internal_has_range_tbl_function()) {
    clear_node();
    set_has_range_tbl_function();
    node_.range_tbl_function_ = CreateMaybeMessage< ::pg_query::RangeTblFunction >(GetArena());
  }
  return node_.range_tbl_function_;
}
inline ::pg_query::RangeTblFunction* Node::mutable_range_tbl_function() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_tbl_function)
  return _internal_mutable_range_tbl_function();
}

// .pg_query.TableSampleClause table_sample_clause = 194 [json_name = "TableSampleClause"];
inline bool Node::_internal_has_table_sample_clause() const {
  return node_case() == kTableSampleClause;
}
inline bool Node::has_table_sample_clause() const {
  return _internal_has_table_sample_clause();
}
inline void Node::set_has_table_sample_clause() {
  _oneof_case_[0] = kTableSampleClause;
}
inline void Node::clear_table_sample_clause() {
  if (_internal_has_table_sample_clause()) {
    if (GetArena() == nullptr) {
      delete node_.table_sample_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::TableSampleClause* Node::release_table_sample_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.table_sample_clause)
  if (_internal_has_table_sample_clause()) {
    clear_has_node();
      ::pg_query::TableSampleClause* temp = node_.table_sample_clause_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.table_sample_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TableSampleClause& Node::_internal_table_sample_clause() const {
  return _internal_has_table_sample_clause()
      ? *node_.table_sample_clause_
      : reinterpret_cast< ::pg_query::TableSampleClause&>(::pg_query::_TableSampleClause_default_instance_);
}
inline const ::pg_query::TableSampleClause& Node::table_sample_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.table_sample_clause)
  return _internal_table_sample_clause();
}
inline ::pg_query::TableSampleClause* Node::unsafe_arena_release_table_sample_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.table_sample_clause)
  if (_internal_has_table_sample_clause()) {
    clear_has_node();
    ::pg_query::TableSampleClause* temp = node_.table_sample_clause_;
    node_.table_sample_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_table_sample_clause(::pg_query::TableSampleClause* table_sample_clause) {
  clear_node();
  if (table_sample_clause) {
    set_has_table_sample_clause();
    node_.table_sample_clause_ = table_sample_clause;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.table_sample_clause)
}
inline ::pg_query::TableSampleClause* Node::_internal_mutable_table_sample_clause() {
  if (!_internal_has_table_sample_clause()) {
    clear_node();
    set_has_table_sample_clause();
    node_.table_sample_clause_ = CreateMaybeMessage< ::pg_query::TableSampleClause >(GetArena());
  }
  return node_.table_sample_clause_;
}
inline ::pg_query::TableSampleClause* Node::mutable_table_sample_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.table_sample_clause)
  return _internal_mutable_table_sample_clause();
}

// .pg_query.WithCheckOption with_check_option = 195 [json_name = "WithCheckOption"];
inline bool Node::_internal_has_with_check_option() const {
  return node_case() == kWithCheckOption;
}
inline bool Node::has_with_check_option() const {
  return _internal_has_with_check_option();
}
inline void Node::set_has_with_check_option() {
  _oneof_case_[0] = kWithCheckOption;
}
inline void Node::clear_with_check_option() {
  if (_internal_has_with_check_option()) {
    if (GetArena() == nullptr) {
      delete node_.with_check_option_;
    }
    clear_has_node();
  }
}
inline ::pg_query::WithCheckOption* Node::release_with_check_option() {
  // @@protoc_insertion_point(field_release:pg_query.Node.with_check_option)
  if (_internal_has_with_check_option()) {
    clear_has_node();
      ::pg_query::WithCheckOption* temp = node_.with_check_option_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.with_check_option_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::WithCheckOption& Node::_internal_with_check_option() const {
  return _internal_has_with_check_option()
      ? *node_.with_check_option_
      : reinterpret_cast< ::pg_query::WithCheckOption&>(::pg_query::_WithCheckOption_default_instance_);
}
inline const ::pg_query::WithCheckOption& Node::with_check_option() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.with_check_option)
  return _internal_with_check_option();
}
inline ::pg_query::WithCheckOption* Node::unsafe_arena_release_with_check_option() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.with_check_option)
  if (_internal_has_with_check_option()) {
    clear_has_node();
    ::pg_query::WithCheckOption* temp = node_.with_check_option_;
    node_.with_check_option_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_with_check_option(::pg_query::WithCheckOption* with_check_option) {
  clear_node();
  if (with_check_option) {
    set_has_with_check_option();
    node_.with_check_option_ = with_check_option;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.with_check_option)
}
inline ::pg_query::WithCheckOption* Node::_internal_mutable_with_check_option() {
  if (!_internal_has_with_check_option()) {
    clear_node();
    set_has_with_check_option();
    node_.with_check_option_ = CreateMaybeMessage< ::pg_query::WithCheckOption >(GetArena());
  }
  return node_.with_check_option_;
}
inline ::pg_query::WithCheckOption* Node::mutable_with_check_option() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.with_check_option)
  return _internal_mutable_with_check_option();
}

// .pg_query.SortGroupClause sort_group_clause = 196 [json_name = "SortGroupClause"];
inline bool Node::_internal_has_sort_group_clause() const {
  return node_case() == kSortGroupClause;
}
inline bool Node::has_sort_group_clause() const {
  return _internal_has_sort_group_clause();
}
inline void Node::set_has_sort_group_clause() {
  _oneof_case_[0] = kSortGroupClause;
}
inline void Node::clear_sort_group_clause() {
  if (_internal_has_sort_group_clause()) {
    if (GetArena() == nullptr) {
      delete node_.sort_group_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::SortGroupClause* Node::release_sort_group_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.sort_group_clause)
  if (_internal_has_sort_group_clause()) {
    clear_has_node();
      ::pg_query::SortGroupClause* temp = node_.sort_group_clause_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.sort_group_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SortGroupClause& Node::_internal_sort_group_clause() const {
  return _internal_has_sort_group_clause()
      ? *node_.sort_group_clause_
      : reinterpret_cast< ::pg_query::SortGroupClause&>(::pg_query::_SortGroupClause_default_instance_);
}
inline const ::pg_query::SortGroupClause& Node::sort_group_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.sort_group_clause)
  return _internal_sort_group_clause();
}
inline ::pg_query::SortGroupClause* Node::unsafe_arena_release_sort_group_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.sort_group_clause)
  if (_internal_has_sort_group_clause()) {
    clear_has_node();
    ::pg_query::SortGroupClause* temp = node_.sort_group_clause_;
    node_.sort_group_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_sort_group_clause(::pg_query::SortGroupClause* sort_group_clause) {
  clear_node();
  if (sort_group_clause) {
    set_has_sort_group_clause();
    node_.sort_group_clause_ = sort_group_clause;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sort_group_clause)
}
inline ::pg_query::SortGroupClause* Node::_internal_mutable_sort_group_clause() {
  if (!_internal_has_sort_group_clause()) {
    clear_node();
    set_has_sort_group_clause();
    node_.sort_group_clause_ = CreateMaybeMessage< ::pg_query::SortGroupClause >(GetArena());
  }
  return node_.sort_group_clause_;
}
inline ::pg_query::SortGroupClause* Node::mutable_sort_group_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.sort_group_clause)
  return _internal_mutable_sort_group_clause();
}

// .pg_query.GroupingSet grouping_set = 197 [json_name = "GroupingSet"];
inline bool Node::_internal_has_grouping_set() const {
  return node_case() == kGroupingSet;
}
inline bool Node::has_grouping_set() const {
  return _internal_has_grouping_set();
}
inline void Node::set_has_grouping_set() {
  _oneof_case_[0] = kGroupingSet;
}
inline void Node::clear_grouping_set() {
  if (_internal_has_grouping_set()) {
    if (GetArena() == nullptr) {
      delete node_.grouping_set_;
    }
    clear_has_node();
  }
}
inline ::pg_query::GroupingSet* Node::release_grouping_set() {
  // @@protoc_insertion_point(field_release:pg_query.Node.grouping_set)
  if (_internal_has_grouping_set()) {
    clear_has_node();
      ::pg_query::GroupingSet* temp = node_.grouping_set_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.grouping_set_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::GroupingSet& Node::_internal_grouping_set() const {
  return _internal_has_grouping_set()
      ? *node_.grouping_set_
      : reinterpret_cast< ::pg_query::GroupingSet&>(::pg_query::_GroupingSet_default_instance_);
}
inline const ::pg_query::GroupingSet& Node::grouping_set() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.grouping_set)
  return _internal_grouping_set();
}
inline ::pg_query::GroupingSet* Node::unsafe_arena_release_grouping_set() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.grouping_set)
  if (_internal_has_grouping_set()) {
    clear_has_node();
    ::pg_query::GroupingSet* temp = node_.grouping_set_;
    node_.grouping_set_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_grouping_set(::pg_query::GroupingSet* grouping_set) {
  clear_node();
  if (grouping_set) {
    set_has_grouping_set();
    node_.grouping_set_ = grouping_set;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.grouping_set)
}
inline ::pg_query::GroupingSet* Node::_internal_mutable_grouping_set() {
  if (!_internal_has_grouping_set()) {
    clear_node();
    set_has_grouping_set();
    node_.grouping_set_ = CreateMaybeMessage< ::pg_query::GroupingSet >(GetArena());
  }
  return node_.grouping_set_;
}
inline ::pg_query::GroupingSet* Node::mutable_grouping_set() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.grouping_set)
  return _internal_mutable_grouping_set();
}

// .pg_query.WindowClause window_clause = 198 [json_name = "WindowClause"];
inline bool Node::_internal_has_window_clause() const {
  return node_case() == kWindowClause;
}
inline bool Node::has_window_clause() const {
  return _internal_has_window_clause();
}
inline void Node::set_has_window_clause() {
  _oneof_case_[0] = kWindowClause;
}
inline void Node::clear_window_clause() {
  if (_internal_has_window_clause()) {
    if (GetArena() == nullptr) {
      delete node_.window_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::WindowClause* Node::release_window_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.window_clause)
  if (_internal_has_window_clause()) {
    clear_has_node();
      ::pg_query::WindowClause* temp = node_.window_clause_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.window_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::WindowClause& Node::_internal_window_clause() const {
  return _internal_has_window_clause()
      ? *node_.window_clause_
      : reinterpret_cast< ::pg_query::WindowClause&>(::pg_query::_WindowClause_default_instance_);
}
inline const ::pg_query::WindowClause& Node::window_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.window_clause)
  return _internal_window_clause();
}
inline ::pg_query::WindowClause* Node::unsafe_arena_release_window_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.window_clause)
  if (_internal_has_window_clause()) {
    clear_has_node();
    ::pg_query::WindowClause* temp = node_.window_clause_;
    node_.window_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_window_clause(::pg_query::WindowClause* window_clause) {
  clear_node();
  if (window_clause) {
    set_has_window_clause();
    node_.window_clause_ = window_clause;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.window_clause)
}
inline ::pg_query::WindowClause* Node::_internal_mutable_window_clause() {
  if (!_internal_has_window_clause()) {
    clear_node();
    set_has_window_clause();
    node_.window_clause_ = CreateMaybeMessage< ::pg_query::WindowClause >(GetArena());
  }
  return node_.window_clause_;
}
inline ::pg_query::WindowClause* Node::mutable_window_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.window_clause)
  return _internal_mutable_window_clause();
}

// .pg_query.ObjectWithArgs object_with_args = 199 [json_name = "ObjectWithArgs"];
inline bool Node::_internal_has_object_with_args() const {
  return node_case() == kObjectWithArgs;
}
inline bool Node::has_object_with_args() const {
  return _internal_has_object_with_args();
}
inline void Node::set_has_object_with_args() {
  _oneof_case_[0] = kObjectWithArgs;
}
inline void Node::clear_object_with_args() {
  if (_internal_has_object_with_args()) {
    if (GetArena() == nullptr) {
      delete node_.object_with_args_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ObjectWithArgs* Node::release_object_with_args() {
  // @@protoc_insertion_point(field_release:pg_query.Node.object_with_args)
  if (_internal_has_object_with_args()) {
    clear_has_node();
      ::pg_query::ObjectWithArgs* temp = node_.object_with_args_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.object_with_args_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ObjectWithArgs& Node::_internal_object_with_args() const {
  return _internal_has_object_with_args()
      ? *node_.object_with_args_
      : reinterpret_cast< ::pg_query::ObjectWithArgs&>(::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& Node::object_with_args() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.object_with_args)
  return _internal_object_with_args();
}
inline ::pg_query::ObjectWithArgs* Node::unsafe_arena_release_object_with_args() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.object_with_args)
  if (_internal_has_object_with_args()) {
    clear_has_node();
    ::pg_query::ObjectWithArgs* temp = node_.object_with_args_;
    node_.object_with_args_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_object_with_args(::pg_query::ObjectWithArgs* object_with_args) {
  clear_node();
  if (object_with_args) {
    set_has_object_with_args();
    node_.object_with_args_ = object_with_args;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.object_with_args)
}
inline ::pg_query::ObjectWithArgs* Node::_internal_mutable_object_with_args() {
  if (!_internal_has_object_with_args()) {
    clear_node();
    set_has_object_with_args();
    node_.object_with_args_ = CreateMaybeMessage< ::pg_query::ObjectWithArgs >(GetArena());
  }
  return node_.object_with_args_;
}
inline ::pg_query::ObjectWithArgs* Node::mutable_object_with_args() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.object_with_args)
  return _internal_mutable_object_with_args();
}

// .pg_query.AccessPriv access_priv = 200 [json_name = "AccessPriv"];
inline bool Node::_internal_has_access_priv() const {
  return node_case() == kAccessPriv;
}
inline bool Node::has_access_priv() const {
  return _internal_has_access_priv();
}
inline void Node::set_has_access_priv() {
  _oneof_case_[0] = kAccessPriv;
}
inline void Node::clear_access_priv() {
  if (_internal_has_access_priv()) {
    if (GetArena() == nullptr) {
      delete node_.access_priv_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AccessPriv* Node::release_access_priv() {
  // @@protoc_insertion_point(field_release:pg_query.Node.access_priv)
  if (_internal_has_access_priv()) {
    clear_has_node();
      ::pg_query::AccessPriv* temp = node_.access_priv_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.access_priv_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AccessPriv& Node::_internal_access_priv() const {
  return _internal_has_access_priv()
      ? *node_.access_priv_
      : reinterpret_cast< ::pg_query::AccessPriv&>(::pg_query::_AccessPriv_default_instance_);
}
inline const ::pg_query::AccessPriv& Node::access_priv() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.access_priv)
  return _internal_access_priv();
}
inline ::pg_query::AccessPriv* Node::unsafe_arena_release_access_priv() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.access_priv)
  if (_internal_has_access_priv()) {
    clear_has_node();
    ::pg_query::AccessPriv* temp = node_.access_priv_;
    node_.access_priv_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_access_priv(::pg_query::AccessPriv* access_priv) {
  clear_node();
  if (access_priv) {
    set_has_access_priv();
    node_.access_priv_ = access_priv;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.access_priv)
}
inline ::pg_query::AccessPriv* Node::_internal_mutable_access_priv() {
  if (!_internal_has_access_priv()) {
    clear_node();
    set_has_access_priv();
    node_.access_priv_ = CreateMaybeMessage< ::pg_query::AccessPriv >(GetArena());
  }
  return node_.access_priv_;
}
inline ::pg_query::AccessPriv* Node::mutable_access_priv() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.access_priv)
  return _internal_mutable_access_priv();
}

// .pg_query.CreateOpClassItem create_op_class_item = 201 [json_name = "CreateOpClassItem"];
inline bool Node::_internal_has_create_op_class_item() const {
  return node_case() == kCreateOpClassItem;
}
inline bool Node::has_create_op_class_item() const {
  return _internal_has_create_op_class_item();
}
inline void Node::set_has_create_op_class_item() {
  _oneof_case_[0] = kCreateOpClassItem;
}
inline void Node::clear_create_op_class_item() {
  if (_internal_has_create_op_class_item()) {
    if (GetArena() == nullptr) {
      delete node_.create_op_class_item_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CreateOpClassItem* Node::release_create_op_class_item() {
  // @@protoc_insertion_point(field_release:pg_query.Node.create_op_class_item)
  if (_internal_has_create_op_class_item()) {
    clear_has_node();
      ::pg_query::CreateOpClassItem* temp = node_.create_op_class_item_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.create_op_class_item_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateOpClassItem& Node::_internal_create_op_class_item() const {
  return _internal_has_create_op_class_item()
      ? *node_.create_op_class_item_
      : reinterpret_cast< ::pg_query::CreateOpClassItem&>(::pg_query::_CreateOpClassItem_default_instance_);
}
inline const ::pg_query::CreateOpClassItem& Node::create_op_class_item() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.create_op_class_item)
  return _internal_create_op_class_item();
}
inline ::pg_query::CreateOpClassItem* Node::unsafe_arena_release_create_op_class_item() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_op_class_item)
  if (_internal_has_create_op_class_item()) {
    clear_has_node();
    ::pg_query::CreateOpClassItem* temp = node_.create_op_class_item_;
    node_.create_op_class_item_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_op_class_item(::pg_query::CreateOpClassItem* create_op_class_item) {
  clear_node();
  if (create_op_class_item) {
    set_has_create_op_class_item();
    node_.create_op_class_item_ = create_op_class_item;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_op_class_item)
}
inline ::pg_query::CreateOpClassItem* Node::_internal_mutable_create_op_class_item() {
  if (!_internal_has_create_op_class_item()) {
    clear_node();
    set_has_create_op_class_item();
    node_.create_op_class_item_ = CreateMaybeMessage< ::pg_query::CreateOpClassItem >(GetArena());
  }
  return node_.create_op_class_item_;
}
inline ::pg_query::CreateOpClassItem* Node::mutable_create_op_class_item() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_op_class_item)
  return _internal_mutable_create_op_class_item();
}

// .pg_query.TableLikeClause table_like_clause = 202 [json_name = "TableLikeClause"];
inline bool Node::_internal_has_table_like_clause() const {
  return node_case() == kTableLikeClause;
}
inline bool Node::has_table_like_clause() const {
  return _internal_has_table_like_clause();
}
inline void Node::set_has_table_like_clause() {
  _oneof_case_[0] = kTableLikeClause;
}
inline void Node::clear_table_like_clause() {
  if (_internal_has_table_like_clause()) {
    if (GetArena() == nullptr) {
      delete node_.table_like_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::TableLikeClause* Node::release_table_like_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.table_like_clause)
  if (_internal_has_table_like_clause()) {
    clear_has_node();
      ::pg_query::TableLikeClause* temp = node_.table_like_clause_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.table_like_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TableLikeClause& Node::_internal_table_like_clause() const {
  return _internal_has_table_like_clause()
      ? *node_.table_like_clause_
      : reinterpret_cast< ::pg_query::TableLikeClause&>(::pg_query::_TableLikeClause_default_instance_);
}
inline const ::pg_query::TableLikeClause& Node::table_like_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.table_like_clause)
  return _internal_table_like_clause();
}
inline ::pg_query::TableLikeClause* Node::unsafe_arena_release_table_like_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.table_like_clause)
  if (_internal_has_table_like_clause()) {
    clear_has_node();
    ::pg_query::TableLikeClause* temp = node_.table_like_clause_;
    node_.table_like_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_table_like_clause(::pg_query::TableLikeClause* table_like_clause) {
  clear_node();
  if (table_like_clause) {
    set_has_table_like_clause();
    node_.table_like_clause_ = table_like_clause;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.table_like_clause)
}
inline ::pg_query::TableLikeClause* Node::_internal_mutable_table_like_clause() {
  if (!_internal_has_table_like_clause()) {
    clear_node();
    set_has_table_like_clause();
    node_.table_like_clause_ = CreateMaybeMessage< ::pg_query::TableLikeClause >(GetArena());
  }
  return node_.table_like_clause_;
}
inline ::pg_query::TableLikeClause* Node::mutable_table_like_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.table_like_clause)
  return _internal_mutable_table_like_clause();
}

// .pg_query.FunctionParameter function_parameter = 203 [json_name = "FunctionParameter"];
inline bool Node::_internal_has_function_parameter() const {
  return node_case() == kFunctionParameter;
}
inline bool Node::has_function_parameter() const {
  return _internal_has_function_parameter();
}
inline void Node::set_has_function_parameter() {
  _oneof_case_[0] = kFunctionParameter;
}
inline void Node::clear_function_parameter() {
  if (_internal_has_function_parameter()) {
    if (GetArena() == nullptr) {
      delete node_.function_parameter_;
    }
    clear_has_node();
  }
}
inline ::pg_query::FunctionParameter* Node::release_function_parameter() {
  // @@protoc_insertion_point(field_release:pg_query.Node.function_parameter)
  if (_internal_has_function_parameter()) {
    clear_has_node();
      ::pg_query::FunctionParameter* temp = node_.function_parameter_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.function_parameter_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FunctionParameter& Node::_internal_function_parameter() const {
  return _internal_has_function_parameter()
      ? *node_.function_parameter_
      : reinterpret_cast< ::pg_query::FunctionParameter&>(::pg_query::_FunctionParameter_default_instance_);
}
inline const ::pg_query::FunctionParameter& Node::function_parameter() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.function_parameter)
  return _internal_function_parameter();
}
inline ::pg_query::FunctionParameter* Node::unsafe_arena_release_function_parameter() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.function_parameter)
  if (_internal_has_function_parameter()) {
    clear_has_node();
    ::pg_query::FunctionParameter* temp = node_.function_parameter_;
    node_.function_parameter_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_function_parameter(::pg_query::FunctionParameter* function_parameter) {
  clear_node();
  if (function_parameter) {
    set_has_function_parameter();
    node_.function_parameter_ = function_parameter;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.function_parameter)
}
inline ::pg_query::FunctionParameter* Node::_internal_mutable_function_parameter() {
  if (!_internal_has_function_parameter()) {
    clear_node();
    set_has_function_parameter();
    node_.function_parameter_ = CreateMaybeMessage< ::pg_query::FunctionParameter >(GetArena());
  }
  return node_.function_parameter_;
}
inline ::pg_query::FunctionParameter* Node::mutable_function_parameter() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.function_parameter)
  return _internal_mutable_function_parameter();
}

// .pg_query.LockingClause locking_clause = 204 [json_name = "LockingClause"];
inline bool Node::_internal_has_locking_clause() const {
  return node_case() == kLockingClause;
}
inline bool Node::has_locking_clause() const {
  return _internal_has_locking_clause();
}
inline void Node::set_has_locking_clause() {
  _oneof_case_[0] = kLockingClause;
}
inline void Node::clear_locking_clause() {
  if (_internal_has_locking_clause()) {
    if (GetArena() == nullptr) {
      delete node_.locking_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::LockingClause* Node::release_locking_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.locking_clause)
  if (_internal_has_locking_clause()) {
    clear_has_node();
      ::pg_query::LockingClause* temp = node_.locking_clause_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.locking_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::LockingClause& Node::_internal_locking_clause() const {
  return _internal_has_locking_clause()
      ? *node_.locking_clause_
      : reinterpret_cast< ::pg_query::LockingClause&>(::pg_query::_LockingClause_default_instance_);
}
inline const ::pg_query::LockingClause& Node::locking_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.locking_clause)
  return _internal_locking_clause();
}
inline ::pg_query::LockingClause* Node::unsafe_arena_release_locking_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.locking_clause)
  if (_internal_has_locking_clause()) {
    clear_has_node();
    ::pg_query::LockingClause* temp = node_.locking_clause_;
    node_.locking_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_locking_clause(::pg_query::LockingClause* locking_clause) {
  clear_node();
  if (locking_clause) {
    set_has_locking_clause();
    node_.locking_clause_ = locking_clause;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.locking_clause)
}
inline ::pg_query::LockingClause* Node::_internal_mutable_locking_clause() {
  if (!_internal_has_locking_clause()) {
    clear_node();
    set_has_locking_clause();
    node_.locking_clause_ = CreateMaybeMessage< ::pg_query::LockingClause >(GetArena());
  }
  return node_.locking_clause_;
}
inline ::pg_query::LockingClause* Node::mutable_locking_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.locking_clause)
  return _internal_mutable_locking_clause();
}

// .pg_query.RowMarkClause row_mark_clause = 205 [json_name = "RowMarkClause"];
inline bool Node::_internal_has_row_mark_clause() const {
  return node_case() == kRowMarkClause;
}
inline bool Node::has_row_mark_clause() const {
  return _internal_has_row_mark_clause();
}
inline void Node::set_has_row_mark_clause() {
  _oneof_case_[0] = kRowMarkClause;
}
inline void Node::clear_row_mark_clause() {
  if (_internal_has_row_mark_clause()) {
    if (GetArena() == nullptr) {
      delete node_.row_mark_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RowMarkClause* Node::release_row_mark_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.row_mark_clause)
  if (_internal_has_row_mark_clause()) {
    clear_has_node();
      ::pg_query::RowMarkClause* temp = node_.row_mark_clause_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.row_mark_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RowMarkClause& Node::_internal_row_mark_clause() const {
  return _internal_has_row_mark_clause()
      ? *node_.row_mark_clause_
      : reinterpret_cast< ::pg_query::RowMarkClause&>(::pg_query::_RowMarkClause_default_instance_);
}
inline const ::pg_query::RowMarkClause& Node::row_mark_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.row_mark_clause)
  return _internal_row_mark_clause();
}
inline ::pg_query::RowMarkClause* Node::unsafe_arena_release_row_mark_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.row_mark_clause)
  if (_internal_has_row_mark_clause()) {
    clear_has_node();
    ::pg_query::RowMarkClause* temp = node_.row_mark_clause_;
    node_.row_mark_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_row_mark_clause(::pg_query::RowMarkClause* row_mark_clause) {
  clear_node();
  if (row_mark_clause) {
    set_has_row_mark_clause();
    node_.row_mark_clause_ = row_mark_clause;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.row_mark_clause)
}
inline ::pg_query::RowMarkClause* Node::_internal_mutable_row_mark_clause() {
  if (!_internal_has_row_mark_clause()) {
    clear_node();
    set_has_row_mark_clause();
    node_.row_mark_clause_ = CreateMaybeMessage< ::pg_query::RowMarkClause >(GetArena());
  }
  return node_.row_mark_clause_;
}
inline ::pg_query::RowMarkClause* Node::mutable_row_mark_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.row_mark_clause)
  return _internal_mutable_row_mark_clause();
}

// .pg_query.XmlSerialize xml_serialize = 206 [json_name = "XmlSerialize"];
inline bool Node::_internal_has_xml_serialize() const {
  return node_case() == kXmlSerialize;
}
inline bool Node::has_xml_serialize() const {
  return _internal_has_xml_serialize();
}
inline void Node::set_has_xml_serialize() {
  _oneof_case_[0] = kXmlSerialize;
}
inline void Node::clear_xml_serialize() {
  if (_internal_has_xml_serialize()) {
    if (GetArena() == nullptr) {
      delete node_.xml_serialize_;
    }
    clear_has_node();
  }
}
inline ::pg_query::XmlSerialize* Node::release_xml_serialize() {
  // @@protoc_insertion_point(field_release:pg_query.Node.xml_serialize)
  if (_internal_has_xml_serialize()) {
    clear_has_node();
      ::pg_query::XmlSerialize* temp = node_.xml_serialize_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.xml_serialize_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::XmlSerialize& Node::_internal_xml_serialize() const {
  return _internal_has_xml_serialize()
      ? *node_.xml_serialize_
      : reinterpret_cast< ::pg_query::XmlSerialize&>(::pg_query::_XmlSerialize_default_instance_);
}
inline const ::pg_query::XmlSerialize& Node::xml_serialize() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.xml_serialize)
  return _internal_xml_serialize();
}
inline ::pg_query::XmlSerialize* Node::unsafe_arena_release_xml_serialize() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.xml_serialize)
  if (_internal_has_xml_serialize()) {
    clear_has_node();
    ::pg_query::XmlSerialize* temp = node_.xml_serialize_;
    node_.xml_serialize_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_xml_serialize(::pg_query::XmlSerialize* xml_serialize) {
  clear_node();
  if (xml_serialize) {
    set_has_xml_serialize();
    node_.xml_serialize_ = xml_serialize;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.xml_serialize)
}
inline ::pg_query::XmlSerialize* Node::_internal_mutable_xml_serialize() {
  if (!_internal_has_xml_serialize()) {
    clear_node();
    set_has_xml_serialize();
    node_.xml_serialize_ = CreateMaybeMessage< ::pg_query::XmlSerialize >(GetArena());
  }
  return node_.xml_serialize_;
}
inline ::pg_query::XmlSerialize* Node::mutable_xml_serialize() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.xml_serialize)
  return _internal_mutable_xml_serialize();
}

// .pg_query.WithClause with_clause = 207 [json_name = "WithClause"];
inline bool Node::_internal_has_with_clause() const {
  return node_case() == kWithClause;
}
inline bool Node::has_with_clause() const {
  return _internal_has_with_clause();
}
inline void Node::set_has_with_clause() {
  _oneof_case_[0] = kWithClause;
}
inline void Node::clear_with_clause() {
  if (_internal_has_with_clause()) {
    if (GetArena() == nullptr) {
      delete node_.with_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::WithClause* Node::release_with_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.with_clause)
  if (_internal_has_with_clause()) {
    clear_has_node();
      ::pg_query::WithClause* temp = node_.with_clause_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.with_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::WithClause& Node::_internal_with_clause() const {
  return _internal_has_with_clause()
      ? *node_.with_clause_
      : reinterpret_cast< ::pg_query::WithClause&>(::pg_query::_WithClause_default_instance_);
}
inline const ::pg_query::WithClause& Node::with_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.with_clause)
  return _internal_with_clause();
}
inline ::pg_query::WithClause* Node::unsafe_arena_release_with_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.with_clause)
  if (_internal_has_with_clause()) {
    clear_has_node();
    ::pg_query::WithClause* temp = node_.with_clause_;
    node_.with_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_with_clause(::pg_query::WithClause* with_clause) {
  clear_node();
  if (with_clause) {
    set_has_with_clause();
    node_.with_clause_ = with_clause;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.with_clause)
}
inline ::pg_query::WithClause* Node::_internal_mutable_with_clause() {
  if (!_internal_has_with_clause()) {
    clear_node();
    set_has_with_clause();
    node_.with_clause_ = CreateMaybeMessage< ::pg_query::WithClause >(GetArena());
  }
  return node_.with_clause_;
}
inline ::pg_query::WithClause* Node::mutable_with_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.with_clause)
  return _internal_mutable_with_clause();
}

// .pg_query.InferClause infer_clause = 208 [json_name = "InferClause"];
inline bool Node::_internal_has_infer_clause() const {
  return node_case() == kInferClause;
}
inline bool Node::has_infer_clause() const {
  return _internal_has_infer_clause();
}
inline void Node::set_has_infer_clause() {
  _oneof_case_[0] = kInferClause;
}
inline void Node::clear_infer_clause() {
  if (_internal_has_infer_clause()) {
    if (GetArena() == nullptr) {
      delete node_.infer_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::InferClause* Node::release_infer_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.infer_clause)
  if (_internal_has_infer_clause()) {
    clear_has_node();
      ::pg_query::InferClause* temp = node_.infer_clause_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.infer_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::InferClause& Node::_internal_infer_clause() const {
  return _internal_has_infer_clause()
      ? *node_.infer_clause_
      : reinterpret_cast< ::pg_query::InferClause&>(::pg_query::_InferClause_default_instance_);
}
inline const ::pg_query::InferClause& Node::infer_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.infer_clause)
  return _internal_infer_clause();
}
inline ::pg_query::InferClause* Node::unsafe_arena_release_infer_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.infer_clause)
  if (_internal_has_infer_clause()) {
    clear_has_node();
    ::pg_query::InferClause* temp = node_.infer_clause_;
    node_.infer_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_infer_clause(::pg_query::InferClause* infer_clause) {
  clear_node();
  if (infer_clause) {
    set_has_infer_clause();
    node_.infer_clause_ = infer_clause;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.infer_clause)
}
inline ::pg_query::InferClause* Node::_internal_mutable_infer_clause() {
  if (!_internal_has_infer_clause()) {
    clear_node();
    set_has_infer_clause();
    node_.infer_clause_ = CreateMaybeMessage< ::pg_query::InferClause >(GetArena());
  }
  return node_.infer_clause_;
}
inline ::pg_query::InferClause* Node::mutable_infer_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.infer_clause)
  return _internal_mutable_infer_clause();
}

// .pg_query.OnConflictClause on_conflict_clause = 209 [json_name = "OnConflictClause"];
inline bool Node::_internal_has_on_conflict_clause() const {
  return node_case() == kOnConflictClause;
}
inline bool Node::has_on_conflict_clause() const {
  return _internal_has_on_conflict_clause();
}
inline void Node::set_has_on_conflict_clause() {
  _oneof_case_[0] = kOnConflictClause;
}
inline void Node::clear_on_conflict_clause() {
  if (_internal_has_on_conflict_clause()) {
    if (GetArena() == nullptr) {
      delete node_.on_conflict_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::OnConflictClause* Node::release_on_conflict_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.on_conflict_clause)
  if (_internal_has_on_conflict_clause()) {
    clear_has_node();
      ::pg_query::OnConflictClause* temp = node_.on_conflict_clause_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.on_conflict_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::OnConflictClause& Node::_internal_on_conflict_clause() const {
  return _internal_has_on_conflict_clause()
      ? *node_.on_conflict_clause_
      : reinterpret_cast< ::pg_query::OnConflictClause&>(::pg_query::_OnConflictClause_default_instance_);
}
inline const ::pg_query::OnConflictClause& Node::on_conflict_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.on_conflict_clause)
  return _internal_on_conflict_clause();
}
inline ::pg_query::OnConflictClause* Node::unsafe_arena_release_on_conflict_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.on_conflict_clause)
  if (_internal_has_on_conflict_clause()) {
    clear_has_node();
    ::pg_query::OnConflictClause* temp = node_.on_conflict_clause_;
    node_.on_conflict_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_on_conflict_clause(::pg_query::OnConflictClause* on_conflict_clause) {
  clear_node();
  if (on_conflict_clause) {
    set_has_on_conflict_clause();
    node_.on_conflict_clause_ = on_conflict_clause;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.on_conflict_clause)
}
inline ::pg_query::OnConflictClause* Node::_internal_mutable_on_conflict_clause() {
  if (!_internal_has_on_conflict_clause()) {
    clear_node();
    set_has_on_conflict_clause();
    node_.on_conflict_clause_ = CreateMaybeMessage< ::pg_query::OnConflictClause >(GetArena());
  }
  return node_.on_conflict_clause_;
}
inline ::pg_query::OnConflictClause* Node::mutable_on_conflict_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.on_conflict_clause)
  return _internal_mutable_on_conflict_clause();
}

// .pg_query.CommonTableExpr common_table_expr = 210 [json_name = "CommonTableExpr"];
inline bool Node::_internal_has_common_table_expr() const {
  return node_case() == kCommonTableExpr;
}
inline bool Node::has_common_table_expr() const {
  return _internal_has_common_table_expr();
}
inline void Node::set_has_common_table_expr() {
  _oneof_case_[0] = kCommonTableExpr;
}
inline void Node::clear_common_table_expr() {
  if (_internal_has_common_table_expr()) {
    if (GetArena() == nullptr) {
      delete node_.common_table_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CommonTableExpr* Node::release_common_table_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.common_table_expr)
  if (_internal_has_common_table_expr()) {
    clear_has_node();
      ::pg_query::CommonTableExpr* temp = node_.common_table_expr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.common_table_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CommonTableExpr& Node::_internal_common_table_expr() const {
  return _internal_has_common_table_expr()
      ? *node_.common_table_expr_
      : reinterpret_cast< ::pg_query::CommonTableExpr&>(::pg_query::_CommonTableExpr_default_instance_);
}
inline const ::pg_query::CommonTableExpr& Node::common_table_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.common_table_expr)
  return _internal_common_table_expr();
}
inline ::pg_query::CommonTableExpr* Node::unsafe_arena_release_common_table_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.common_table_expr)
  if (_internal_has_common_table_expr()) {
    clear_has_node();
    ::pg_query::CommonTableExpr* temp = node_.common_table_expr_;
    node_.common_table_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_common_table_expr(::pg_query::CommonTableExpr* common_table_expr) {
  clear_node();
  if (common_table_expr) {
    set_has_common_table_expr();
    node_.common_table_expr_ = common_table_expr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.common_table_expr)
}
inline ::pg_query::CommonTableExpr* Node::_internal_mutable_common_table_expr() {
  if (!_internal_has_common_table_expr()) {
    clear_node();
    set_has_common_table_expr();
    node_.common_table_expr_ = CreateMaybeMessage< ::pg_query::CommonTableExpr >(GetArena());
  }
  return node_.common_table_expr_;
}
inline ::pg_query::CommonTableExpr* Node::mutable_common_table_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.common_table_expr)
  return _internal_mutable_common_table_expr();
}

// .pg_query.RoleSpec role_spec = 211 [json_name = "RoleSpec"];
inline bool Node::_internal_has_role_spec() const {
  return node_case() == kRoleSpec;
}
inline bool Node::has_role_spec() const {
  return _internal_has_role_spec();
}
inline void Node::set_has_role_spec() {
  _oneof_case_[0] = kRoleSpec;
}
inline void Node::clear_role_spec() {
  if (_internal_has_role_spec()) {
    if (GetArena() == nullptr) {
      delete node_.role_spec_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RoleSpec* Node::release_role_spec() {
  // @@protoc_insertion_point(field_release:pg_query.Node.role_spec)
  if (_internal_has_role_spec()) {
    clear_has_node();
      ::pg_query::RoleSpec* temp = node_.role_spec_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.role_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RoleSpec& Node::_internal_role_spec() const {
  return _internal_has_role_spec()
      ? *node_.role_spec_
      : reinterpret_cast< ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& Node::role_spec() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.role_spec)
  return _internal_role_spec();
}
inline ::pg_query::RoleSpec* Node::unsafe_arena_release_role_spec() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.role_spec)
  if (_internal_has_role_spec()) {
    clear_has_node();
    ::pg_query::RoleSpec* temp = node_.role_spec_;
    node_.role_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_role_spec(::pg_query::RoleSpec* role_spec) {
  clear_node();
  if (role_spec) {
    set_has_role_spec();
    node_.role_spec_ = role_spec;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.role_spec)
}
inline ::pg_query::RoleSpec* Node::_internal_mutable_role_spec() {
  if (!_internal_has_role_spec()) {
    clear_node();
    set_has_role_spec();
    node_.role_spec_ = CreateMaybeMessage< ::pg_query::RoleSpec >(GetArena());
  }
  return node_.role_spec_;
}
inline ::pg_query::RoleSpec* Node::mutable_role_spec() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.role_spec)
  return _internal_mutable_role_spec();
}

// .pg_query.TriggerTransition trigger_transition = 212 [json_name = "TriggerTransition"];
inline bool Node::_internal_has_trigger_transition() const {
  return node_case() == kTriggerTransition;
}
inline bool Node::has_trigger_transition() const {
  return _internal_has_trigger_transition();
}
inline void Node::set_has_trigger_transition() {
  _oneof_case_[0] = kTriggerTransition;
}
inline void Node::clear_trigger_transition() {
  if (_internal_has_trigger_transition()) {
    if (GetArena() == nullptr) {
      delete node_.trigger_transition_;
    }
    clear_has_node();
  }
}
inline ::pg_query::TriggerTransition* Node::release_trigger_transition() {
  // @@protoc_insertion_point(field_release:pg_query.Node.trigger_transition)
  if (_internal_has_trigger_transition()) {
    clear_has_node();
      ::pg_query::TriggerTransition* temp = node_.trigger_transition_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.trigger_transition_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TriggerTransition& Node::_internal_trigger_transition() const {
  return _internal_has_trigger_transition()
      ? *node_.trigger_transition_
      : reinterpret_cast< ::pg_query::TriggerTransition&>(::pg_query::_TriggerTransition_default_instance_);
}
inline const ::pg_query::TriggerTransition& Node::trigger_transition() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.trigger_transition)
  return _internal_trigger_transition();
}
inline ::pg_query::TriggerTransition* Node::unsafe_arena_release_trigger_transition() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.trigger_transition)
  if (_internal_has_trigger_transition()) {
    clear_has_node();
    ::pg_query::TriggerTransition* temp = node_.trigger_transition_;
    node_.trigger_transition_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_trigger_transition(::pg_query::TriggerTransition* trigger_transition) {
  clear_node();
  if (trigger_transition) {
    set_has_trigger_transition();
    node_.trigger_transition_ = trigger_transition;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.trigger_transition)
}
inline ::pg_query::TriggerTransition* Node::_internal_mutable_trigger_transition() {
  if (!_internal_has_trigger_transition()) {
    clear_node();
    set_has_trigger_transition();
    node_.trigger_transition_ = CreateMaybeMessage< ::pg_query::TriggerTransition >(GetArena());
  }
  return node_.trigger_transition_;
}
inline ::pg_query::TriggerTransition* Node::mutable_trigger_transition() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.trigger_transition)
  return _internal_mutable_trigger_transition();
}

// .pg_query.PartitionElem partition_elem = 213 [json_name = "PartitionElem"];
inline bool Node::_internal_has_partition_elem() const {
  return node_case() == kPartitionElem;
}
inline bool Node::has_partition_elem() const {
  return _internal_has_partition_elem();
}
inline void Node::set_has_partition_elem() {
  _oneof_case_[0] = kPartitionElem;
}
inline void Node::clear_partition_elem() {
  if (_internal_has_partition_elem()) {
    if (GetArena() == nullptr) {
      delete node_.partition_elem_;
    }
    clear_has_node();
  }
}
inline ::pg_query::PartitionElem* Node::release_partition_elem() {
  // @@protoc_insertion_point(field_release:pg_query.Node.partition_elem)
  if (_internal_has_partition_elem()) {
    clear_has_node();
      ::pg_query::PartitionElem* temp = node_.partition_elem_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.partition_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PartitionElem& Node::_internal_partition_elem() const {
  return _internal_has_partition_elem()
      ? *node_.partition_elem_
      : reinterpret_cast< ::pg_query::PartitionElem&>(::pg_query::_PartitionElem_default_instance_);
}
inline const ::pg_query::PartitionElem& Node::partition_elem() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.partition_elem)
  return _internal_partition_elem();
}
inline ::pg_query::PartitionElem* Node::unsafe_arena_release_partition_elem() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.partition_elem)
  if (_internal_has_partition_elem()) {
    clear_has_node();
    ::pg_query::PartitionElem* temp = node_.partition_elem_;
    node_.partition_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_partition_elem(::pg_query::PartitionElem* partition_elem) {
  clear_node();
  if (partition_elem) {
    set_has_partition_elem();
    node_.partition_elem_ = partition_elem;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.partition_elem)
}
inline ::pg_query::PartitionElem* Node::_internal_mutable_partition_elem() {
  if (!_internal_has_partition_elem()) {
    clear_node();
    set_has_partition_elem();
    node_.partition_elem_ = CreateMaybeMessage< ::pg_query::PartitionElem >(GetArena());
  }
  return node_.partition_elem_;
}
inline ::pg_query::PartitionElem* Node::mutable_partition_elem() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.partition_elem)
  return _internal_mutable_partition_elem();
}

// .pg_query.PartitionSpec partition_spec = 214 [json_name = "PartitionSpec"];
inline bool Node::_internal_has_partition_spec() const {
  return node_case() == kPartitionSpec;
}
inline bool Node::has_partition_spec() const {
  return _internal_has_partition_spec();
}
inline void Node::set_has_partition_spec() {
  _oneof_case_[0] = kPartitionSpec;
}
inline void Node::clear_partition_spec() {
  if (_internal_has_partition_spec()) {
    if (GetArena() == nullptr) {
      delete node_.partition_spec_;
    }
    clear_has_node();
  }
}
inline ::pg_query::PartitionSpec* Node::release_partition_spec() {
  // @@protoc_insertion_point(field_release:pg_query.Node.partition_spec)
  if (_internal_has_partition_spec()) {
    clear_has_node();
      ::pg_query::PartitionSpec* temp = node_.partition_spec_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.partition_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PartitionSpec& Node::_internal_partition_spec() const {
  return _internal_has_partition_spec()
      ? *node_.partition_spec_
      : reinterpret_cast< ::pg_query::PartitionSpec&>(::pg_query::_PartitionSpec_default_instance_);
}
inline const ::pg_query::PartitionSpec& Node::partition_spec() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.partition_spec)
  return _internal_partition_spec();
}
inline ::pg_query::PartitionSpec* Node::unsafe_arena_release_partition_spec() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.partition_spec)
  if (_internal_has_partition_spec()) {
    clear_has_node();
    ::pg_query::PartitionSpec* temp = node_.partition_spec_;
    node_.partition_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_partition_spec(::pg_query::PartitionSpec* partition_spec) {
  clear_node();
  if (partition_spec) {
    set_has_partition_spec();
    node_.partition_spec_ = partition_spec;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.partition_spec)
}
inline ::pg_query::PartitionSpec* Node::_internal_mutable_partition_spec() {
  if (!_internal_has_partition_spec()) {
    clear_node();
    set_has_partition_spec();
    node_.partition_spec_ = CreateMaybeMessage< ::pg_query::PartitionSpec >(GetArena());
  }
  return node_.partition_spec_;
}
inline ::pg_query::PartitionSpec* Node::mutable_partition_spec() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.partition_spec)
  return _internal_mutable_partition_spec();
}

// .pg_query.PartitionBoundSpec partition_bound_spec = 215 [json_name = "PartitionBoundSpec"];
inline bool Node::_internal_has_partition_bound_spec() const {
  return node_case() == kPartitionBoundSpec;
}
inline bool Node::has_partition_bound_spec() const {
  return _internal_has_partition_bound_spec();
}
inline void Node::set_has_partition_bound_spec() {
  _oneof_case_[0] = kPartitionBoundSpec;
}
inline void Node::clear_partition_bound_spec() {
  if (_internal_has_partition_bound_spec()) {
    if (GetArena() == nullptr) {
      delete node_.partition_bound_spec_;
    }
    clear_has_node();
  }
}
inline ::pg_query::PartitionBoundSpec* Node::release_partition_bound_spec() {
  // @@protoc_insertion_point(field_release:pg_query.Node.partition_bound_spec)
  if (_internal_has_partition_bound_spec()) {
    clear_has_node();
      ::pg_query::PartitionBoundSpec* temp = node_.partition_bound_spec_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.partition_bound_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PartitionBoundSpec& Node::_internal_partition_bound_spec() const {
  return _internal_has_partition_bound_spec()
      ? *node_.partition_bound_spec_
      : reinterpret_cast< ::pg_query::PartitionBoundSpec&>(::pg_query::_PartitionBoundSpec_default_instance_);
}
inline const ::pg_query::PartitionBoundSpec& Node::partition_bound_spec() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.partition_bound_spec)
  return _internal_partition_bound_spec();
}
inline ::pg_query::PartitionBoundSpec* Node::unsafe_arena_release_partition_bound_spec() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.partition_bound_spec)
  if (_internal_has_partition_bound_spec()) {
    clear_has_node();
    ::pg_query::PartitionBoundSpec* temp = node_.partition_bound_spec_;
    node_.partition_bound_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_partition_bound_spec(::pg_query::PartitionBoundSpec* partition_bound_spec) {
  clear_node();
  if (partition_bound_spec) {
    set_has_partition_bound_spec();
    node_.partition_bound_spec_ = partition_bound_spec;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.partition_bound_spec)
}
inline ::pg_query::PartitionBoundSpec* Node::_internal_mutable_partition_bound_spec() {
  if (!_internal_has_partition_bound_spec()) {
    clear_node();
    set_has_partition_bound_spec();
    node_.partition_bound_spec_ = CreateMaybeMessage< ::pg_query::PartitionBoundSpec >(GetArena());
  }
  return node_.partition_bound_spec_;
}
inline ::pg_query::PartitionBoundSpec* Node::mutable_partition_bound_spec() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.partition_bound_spec)
  return _internal_mutable_partition_bound_spec();
}

// .pg_query.PartitionRangeDatum partition_range_datum = 216 [json_name = "PartitionRangeDatum"];
inline bool Node::_internal_has_partition_range_datum() const {
  return node_case() == kPartitionRangeDatum;
}
inline bool Node::has_partition_range_datum() const {
  return _internal_has_partition_range_datum();
}
inline void Node::set_has_partition_range_datum() {
  _oneof_case_[0] = kPartitionRangeDatum;
}
inline void Node::clear_partition_range_datum() {
  if (_internal_has_partition_range_datum()) {
    if (GetArena() == nullptr) {
      delete node_.partition_range_datum_;
    }
    clear_has_node();
  }
}
inline ::pg_query::PartitionRangeDatum* Node::release_partition_range_datum() {
  // @@protoc_insertion_point(field_release:pg_query.Node.partition_range_datum)
  if (_internal_has_partition_range_datum()) {
    clear_has_node();
      ::pg_query::PartitionRangeDatum* temp = node_.partition_range_datum_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.partition_range_datum_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PartitionRangeDatum& Node::_internal_partition_range_datum() const {
  return _internal_has_partition_range_datum()
      ? *node_.partition_range_datum_
      : reinterpret_cast< ::pg_query::PartitionRangeDatum&>(::pg_query::_PartitionRangeDatum_default_instance_);
}
inline const ::pg_query::PartitionRangeDatum& Node::partition_range_datum() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.partition_range_datum)
  return _internal_partition_range_datum();
}
inline ::pg_query::PartitionRangeDatum* Node::unsafe_arena_release_partition_range_datum() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.partition_range_datum)
  if (_internal_has_partition_range_datum()) {
    clear_has_node();
    ::pg_query::PartitionRangeDatum* temp = node_.partition_range_datum_;
    node_.partition_range_datum_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_partition_range_datum(::pg_query::PartitionRangeDatum* partition_range_datum) {
  clear_node();
  if (partition_range_datum) {
    set_has_partition_range_datum();
    node_.partition_range_datum_ = partition_range_datum;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.partition_range_datum)
}
inline ::pg_query::PartitionRangeDatum* Node::_internal_mutable_partition_range_datum() {
  if (!_internal_has_partition_range_datum()) {
    clear_node();
    set_has_partition_range_datum();
    node_.partition_range_datum_ = CreateMaybeMessage< ::pg_query::PartitionRangeDatum >(GetArena());
  }
  return node_.partition_range_datum_;
}
inline ::pg_query::PartitionRangeDatum* Node::mutable_partition_range_datum() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.partition_range_datum)
  return _internal_mutable_partition_range_datum();
}

// .pg_query.PartitionCmd partition_cmd = 217 [json_name = "PartitionCmd"];
inline bool Node::_internal_has_partition_cmd() const {
  return node_case() == kPartitionCmd;
}
inline bool Node::has_partition_cmd() const {
  return _internal_has_partition_cmd();
}
inline void Node::set_has_partition_cmd() {
  _oneof_case_[0] = kPartitionCmd;
}
inline void Node::clear_partition_cmd() {
  if (_internal_has_partition_cmd()) {
    if (GetArena() == nullptr) {
      delete node_.partition_cmd_;
    }
    clear_has_node();
  }
}
inline ::pg_query::PartitionCmd* Node::release_partition_cmd() {
  // @@protoc_insertion_point(field_release:pg_query.Node.partition_cmd)
  if (_internal_has_partition_cmd()) {
    clear_has_node();
      ::pg_query::PartitionCmd* temp = node_.partition_cmd_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.partition_cmd_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PartitionCmd& Node::_internal_partition_cmd() const {
  return _internal_has_partition_cmd()
      ? *node_.partition_cmd_
      : reinterpret_cast< ::pg_query::PartitionCmd&>(::pg_query::_PartitionCmd_default_instance_);
}
inline const ::pg_query::PartitionCmd& Node::partition_cmd() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.partition_cmd)
  return _internal_partition_cmd();
}
inline ::pg_query::PartitionCmd* Node::unsafe_arena_release_partition_cmd() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.partition_cmd)
  if (_internal_has_partition_cmd()) {
    clear_has_node();
    ::pg_query::PartitionCmd* temp = node_.partition_cmd_;
    node_.partition_cmd_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_partition_cmd(::pg_query::PartitionCmd* partition_cmd) {
  clear_node();
  if (partition_cmd) {
    set_has_partition_cmd();
    node_.partition_cmd_ = partition_cmd;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.partition_cmd)
}
inline ::pg_query::PartitionCmd* Node::_internal_mutable_partition_cmd() {
  if (!_internal_has_partition_cmd()) {
    clear_node();
    set_has_partition_cmd();
    node_.partition_cmd_ = CreateMaybeMessage< ::pg_query::PartitionCmd >(GetArena());
  }
  return node_.partition_cmd_;
}
inline ::pg_query::PartitionCmd* Node::mutable_partition_cmd() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.partition_cmd)
  return _internal_mutable_partition_cmd();
}

// .pg_query.VacuumRelation vacuum_relation = 218 [json_name = "VacuumRelation"];
inline bool Node::_internal_has_vacuum_relation() const {
  return node_case() == kVacuumRelation;
}
inline bool Node::has_vacuum_relation() const {
  return _internal_has_vacuum_relation();
}
inline void Node::set_has_vacuum_relation() {
  _oneof_case_[0] = kVacuumRelation;
}
inline void Node::clear_vacuum_relation() {
  if (_internal_has_vacuum_relation()) {
    if (GetArena() == nullptr) {
      delete node_.vacuum_relation_;
    }
    clear_has_node();
  }
}
inline ::pg_query::VacuumRelation* Node::release_vacuum_relation() {
  // @@protoc_insertion_point(field_release:pg_query.Node.vacuum_relation)
  if (_internal_has_vacuum_relation()) {
    clear_has_node();
      ::pg_query::VacuumRelation* temp = node_.vacuum_relation_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.vacuum_relation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::VacuumRelation& Node::_internal_vacuum_relation() const {
  return _internal_has_vacuum_relation()
      ? *node_.vacuum_relation_
      : reinterpret_cast< ::pg_query::VacuumRelation&>(::pg_query::_VacuumRelation_default_instance_);
}
inline const ::pg_query::VacuumRelation& Node::vacuum_relation() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.vacuum_relation)
  return _internal_vacuum_relation();
}
inline ::pg_query::VacuumRelation* Node::unsafe_arena_release_vacuum_relation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.vacuum_relation)
  if (_internal_has_vacuum_relation()) {
    clear_has_node();
    ::pg_query::VacuumRelation* temp = node_.vacuum_relation_;
    node_.vacuum_relation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_vacuum_relation(::pg_query::VacuumRelation* vacuum_relation) {
  clear_node();
  if (vacuum_relation) {
    set_has_vacuum_relation();
    node_.vacuum_relation_ = vacuum_relation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.vacuum_relation)
}
inline ::pg_query::VacuumRelation* Node::_internal_mutable_vacuum_relation() {
  if (!_internal_has_vacuum_relation()) {
    clear_node();
    set_has_vacuum_relation();
    node_.vacuum_relation_ = CreateMaybeMessage< ::pg_query::VacuumRelation >(GetArena());
  }
  return node_.vacuum_relation_;
}
inline ::pg_query::VacuumRelation* Node::mutable_vacuum_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.vacuum_relation)
  return _internal_mutable_vacuum_relation();
}

// .pg_query.InlineCodeBlock inline_code_block = 219 [json_name = "InlineCodeBlock"];
inline bool Node::_internal_has_inline_code_block() const {
  return node_case() == kInlineCodeBlock;
}
inline bool Node::has_inline_code_block() const {
  return _internal_has_inline_code_block();
}
inline void Node::set_has_inline_code_block() {
  _oneof_case_[0] = kInlineCodeBlock;
}
inline void Node::clear_inline_code_block() {
  if (_internal_has_inline_code_block()) {
    if (GetArena() == nullptr) {
      delete node_.inline_code_block_;
    }
    clear_has_node();
  }
}
inline ::pg_query::InlineCodeBlock* Node::release_inline_code_block() {
  // @@protoc_insertion_point(field_release:pg_query.Node.inline_code_block)
  if (_internal_has_inline_code_block()) {
    clear_has_node();
      ::pg_query::InlineCodeBlock* temp = node_.inline_code_block_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.inline_code_block_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::InlineCodeBlock& Node::_internal_inline_code_block() const {
  return _internal_has_inline_code_block()
      ? *node_.inline_code_block_
      : reinterpret_cast< ::pg_query::InlineCodeBlock&>(::pg_query::_InlineCodeBlock_default_instance_);
}
inline const ::pg_query::InlineCodeBlock& Node::inline_code_block() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.inline_code_block)
  return _internal_inline_code_block();
}
inline ::pg_query::InlineCodeBlock* Node::unsafe_arena_release_inline_code_block() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.inline_code_block)
  if (_internal_has_inline_code_block()) {
    clear_has_node();
    ::pg_query::InlineCodeBlock* temp = node_.inline_code_block_;
    node_.inline_code_block_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_inline_code_block(::pg_query::InlineCodeBlock* inline_code_block) {
  clear_node();
  if (inline_code_block) {
    set_has_inline_code_block();
    node_.inline_code_block_ = inline_code_block;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.inline_code_block)
}
inline ::pg_query::InlineCodeBlock* Node::_internal_mutable_inline_code_block() {
  if (!_internal_has_inline_code_block()) {
    clear_node();
    set_has_inline_code_block();
    node_.inline_code_block_ = CreateMaybeMessage< ::pg_query::InlineCodeBlock >(GetArena());
  }
  return node_.inline_code_block_;
}
inline ::pg_query::InlineCodeBlock* Node::mutable_inline_code_block() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.inline_code_block)
  return _internal_mutable_inline_code_block();
}

// .pg_query.CallContext call_context = 220 [json_name = "CallContext"];
inline bool Node::_internal_has_call_context() const {
  return node_case() == kCallContext;
}
inline bool Node::has_call_context() const {
  return _internal_has_call_context();
}
inline void Node::set_has_call_context() {
  _oneof_case_[0] = kCallContext;
}
inline void Node::clear_call_context() {
  if (_internal_has_call_context()) {
    if (GetArena() == nullptr) {
      delete node_.call_context_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CallContext* Node::release_call_context() {
  // @@protoc_insertion_point(field_release:pg_query.Node.call_context)
  if (_internal_has_call_context()) {
    clear_has_node();
      ::pg_query::CallContext* temp = node_.call_context_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.call_context_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CallContext& Node::_internal_call_context() const {
  return _internal_has_call_context()
      ? *node_.call_context_
      : reinterpret_cast< ::pg_query::CallContext&>(::pg_query::_CallContext_default_instance_);
}
inline const ::pg_query::CallContext& Node::call_context() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.call_context)
  return _internal_call_context();
}
inline ::pg_query::CallContext* Node::unsafe_arena_release_call_context() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.call_context)
  if (_internal_has_call_context()) {
    clear_has_node();
    ::pg_query::CallContext* temp = node_.call_context_;
    node_.call_context_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_call_context(::pg_query::CallContext* call_context) {
  clear_node();
  if (call_context) {
    set_has_call_context();
    node_.call_context_ = call_context;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.call_context)
}
inline ::pg_query::CallContext* Node::_internal_mutable_call_context() {
  if (!_internal_has_call_context()) {
    clear_node();
    set_has_call_context();
    node_.call_context_ = CreateMaybeMessage< ::pg_query::CallContext >(GetArena());
  }
  return node_.call_context_;
}
inline ::pg_query::CallContext* Node::mutable_call_context() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.call_context)
  return _internal_mutable_call_context();
}

// .pg_query.Integer integer = 221 [json_name = "Integer"];
inline bool Node::_internal_has_integer() const {
  return node_case() == kInteger;
}
inline bool Node::has_integer() const {
  return _internal_has_integer();
}
inline void Node::set_has_integer() {
  _oneof_case_[0] = kInteger;
}
inline void Node::clear_integer() {
  if (_internal_has_integer()) {
    if (GetArena() == nullptr) {
      delete node_.integer_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Integer* Node::release_integer() {
  // @@protoc_insertion_point(field_release:pg_query.Node.integer)
  if (_internal_has_integer()) {
    clear_has_node();
      ::pg_query::Integer* temp = node_.integer_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.integer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Integer& Node::_internal_integer() const {
  return _internal_has_integer()
      ? *node_.integer_
      : reinterpret_cast< ::pg_query::Integer&>(::pg_query::_Integer_default_instance_);
}
inline const ::pg_query::Integer& Node::integer() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.integer)
  return _internal_integer();
}
inline ::pg_query::Integer* Node::unsafe_arena_release_integer() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.integer)
  if (_internal_has_integer()) {
    clear_has_node();
    ::pg_query::Integer* temp = node_.integer_;
    node_.integer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_integer(::pg_query::Integer* integer) {
  clear_node();
  if (integer) {
    set_has_integer();
    node_.integer_ = integer;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.integer)
}
inline ::pg_query::Integer* Node::_internal_mutable_integer() {
  if (!_internal_has_integer()) {
    clear_node();
    set_has_integer();
    node_.integer_ = CreateMaybeMessage< ::pg_query::Integer >(GetArena());
  }
  return node_.integer_;
}
inline ::pg_query::Integer* Node::mutable_integer() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.integer)
  return _internal_mutable_integer();
}

// .pg_query.Float float = 222 [json_name = "Float"];
inline bool Node::_internal_has_float_() const {
  return node_case() == kFloat;
}
inline bool Node::has_float_() const {
  return _internal_has_float_();
}
inline void Node::set_has_float_() {
  _oneof_case_[0] = kFloat;
}
inline void Node::clear_float_() {
  if (_internal_has_float_()) {
    if (GetArena() == nullptr) {
      delete node_.float__;
    }
    clear_has_node();
  }
}
inline ::pg_query::Float* Node::release_float_() {
  // @@protoc_insertion_point(field_release:pg_query.Node.float)
  if (_internal_has_float_()) {
    clear_has_node();
      ::pg_query::Float* temp = node_.float__;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.float__ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Float& Node::_internal_float_() const {
  return _internal_has_float_()
      ? *node_.float__
      : reinterpret_cast< ::pg_query::Float&>(::pg_query::_Float_default_instance_);
}
inline const ::pg_query::Float& Node::float_() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.float)
  return _internal_float_();
}
inline ::pg_query::Float* Node::unsafe_arena_release_float_() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.float)
  if (_internal_has_float_()) {
    clear_has_node();
    ::pg_query::Float* temp = node_.float__;
    node_.float__ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_float_(::pg_query::Float* float_) {
  clear_node();
  if (float_) {
    set_has_float_();
    node_.float__ = float_;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.float)
}
inline ::pg_query::Float* Node::_internal_mutable_float_() {
  if (!_internal_has_float_()) {
    clear_node();
    set_has_float_();
    node_.float__ = CreateMaybeMessage< ::pg_query::Float >(GetArena());
  }
  return node_.float__;
}
inline ::pg_query::Float* Node::mutable_float_() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.float)
  return _internal_mutable_float_();
}

// .pg_query.String string = 223 [json_name = "String"];
inline bool Node::_internal_has_string() const {
  return node_case() == kString;
}
inline bool Node::has_string() const {
  return _internal_has_string();
}
inline void Node::set_has_string() {
  _oneof_case_[0] = kString;
}
inline void Node::clear_string() {
  if (_internal_has_string()) {
    if (GetArena() == nullptr) {
      delete node_.string_;
    }
    clear_has_node();
  }
}
inline ::pg_query::String* Node::release_string() {
  // @@protoc_insertion_point(field_release:pg_query.Node.string)
  if (_internal_has_string()) {
    clear_has_node();
      ::pg_query::String* temp = node_.string_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.string_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::String& Node::_internal_string() const {
  return _internal_has_string()
      ? *node_.string_
      : reinterpret_cast< ::pg_query::String&>(::pg_query::_String_default_instance_);
}
inline const ::pg_query::String& Node::string() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.string)
  return _internal_string();
}
inline ::pg_query::String* Node::unsafe_arena_release_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.string)
  if (_internal_has_string()) {
    clear_has_node();
    ::pg_query::String* temp = node_.string_;
    node_.string_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_string(::pg_query::String* string) {
  clear_node();
  if (string) {
    set_has_string();
    node_.string_ = string;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.string)
}
inline ::pg_query::String* Node::_internal_mutable_string() {
  if (!_internal_has_string()) {
    clear_node();
    set_has_string();
    node_.string_ = CreateMaybeMessage< ::pg_query::String >(GetArena());
  }
  return node_.string_;
}
inline ::pg_query::String* Node::mutable_string() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.string)
  return _internal_mutable_string();
}

// .pg_query.BitString bit_string = 224 [json_name = "BitString"];
inline bool Node::_internal_has_bit_string() const {
  return node_case() == kBitString;
}
inline bool Node::has_bit_string() const {
  return _internal_has_bit_string();
}
inline void Node::set_has_bit_string() {
  _oneof_case_[0] = kBitString;
}
inline void Node::clear_bit_string() {
  if (_internal_has_bit_string()) {
    if (GetArena() == nullptr) {
      delete node_.bit_string_;
    }
    clear_has_node();
  }
}
inline ::pg_query::BitString* Node::release_bit_string() {
  // @@protoc_insertion_point(field_release:pg_query.Node.bit_string)
  if (_internal_has_bit_string()) {
    clear_has_node();
      ::pg_query::BitString* temp = node_.bit_string_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.bit_string_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::BitString& Node::_internal_bit_string() const {
  return _internal_has_bit_string()
      ? *node_.bit_string_
      : reinterpret_cast< ::pg_query::BitString&>(::pg_query::_BitString_default_instance_);
}
inline const ::pg_query::BitString& Node::bit_string() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.bit_string)
  return _internal_bit_string();
}
inline ::pg_query::BitString* Node::unsafe_arena_release_bit_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.bit_string)
  if (_internal_has_bit_string()) {
    clear_has_node();
    ::pg_query::BitString* temp = node_.bit_string_;
    node_.bit_string_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_bit_string(::pg_query::BitString* bit_string) {
  clear_node();
  if (bit_string) {
    set_has_bit_string();
    node_.bit_string_ = bit_string;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.bit_string)
}
inline ::pg_query::BitString* Node::_internal_mutable_bit_string() {
  if (!_internal_has_bit_string()) {
    clear_node();
    set_has_bit_string();
    node_.bit_string_ = CreateMaybeMessage< ::pg_query::BitString >(GetArena());
  }
  return node_.bit_string_;
}
inline ::pg_query::BitString* Node::mutable_bit_string() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.bit_string)
  return _internal_mutable_bit_string();
}

// .pg_query.Null null = 225 [json_name = "Null"];
inline bool Node::_internal_has_null() const {
  return node_case() == kNull;
}
inline bool Node::has_null() const {
  return _internal_has_null();
}
inline void Node::set_has_null() {
  _oneof_case_[0] = kNull;
}
inline void Node::clear_null() {
  if (_internal_has_null()) {
    if (GetArena() == nullptr) {
      delete node_.null_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Null* Node::release_null() {
  // @@protoc_insertion_point(field_release:pg_query.Node.null)
  if (_internal_has_null()) {
    clear_has_node();
      ::pg_query::Null* temp = node_.null_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.null_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Null& Node::_internal_null() const {
  return _internal_has_null()
      ? *node_.null_
      : reinterpret_cast< ::pg_query::Null&>(::pg_query::_Null_default_instance_);
}
inline const ::pg_query::Null& Node::null() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.null)
  return _internal_null();
}
inline ::pg_query::Null* Node::unsafe_arena_release_null() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.null)
  if (_internal_has_null()) {
    clear_has_node();
    ::pg_query::Null* temp = node_.null_;
    node_.null_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_null(::pg_query::Null* null) {
  clear_node();
  if (null) {
    set_has_null();
    node_.null_ = null;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.null)
}
inline ::pg_query::Null* Node::_internal_mutable_null() {
  if (!_internal_has_null()) {
    clear_node();
    set_has_null();
    node_.null_ = CreateMaybeMessage< ::pg_query::Null >(GetArena());
  }
  return node_.null_;
}
inline ::pg_query::Null* Node::mutable_null() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.null)
  return _internal_mutable_null();
}

// .pg_query.List list = 226 [json_name = "List"];
inline bool Node::_internal_has_list() const {
  return node_case() == kList;
}
inline bool Node::has_list() const {
  return _internal_has_list();
}
inline void Node::set_has_list() {
  _oneof_case_[0] = kList;
}
inline void Node::clear_list() {
  if (_internal_has_list()) {
    if (GetArena() == nullptr) {
      delete node_.list_;
    }
    clear_has_node();
  }
}
inline ::pg_query::List* Node::release_list() {
  // @@protoc_insertion_point(field_release:pg_query.Node.list)
  if (_internal_has_list()) {
    clear_has_node();
      ::pg_query::List* temp = node_.list_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::List& Node::_internal_list() const {
  return _internal_has_list()
      ? *node_.list_
      : reinterpret_cast< ::pg_query::List&>(::pg_query::_List_default_instance_);
}
inline const ::pg_query::List& Node::list() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.list)
  return _internal_list();
}
inline ::pg_query::List* Node::unsafe_arena_release_list() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.list)
  if (_internal_has_list()) {
    clear_has_node();
    ::pg_query::List* temp = node_.list_;
    node_.list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_list(::pg_query::List* list) {
  clear_node();
  if (list) {
    set_has_list();
    node_.list_ = list;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.list)
}
inline ::pg_query::List* Node::_internal_mutable_list() {
  if (!_internal_has_list()) {
    clear_node();
    set_has_list();
    node_.list_ = CreateMaybeMessage< ::pg_query::List >(GetArena());
  }
  return node_.list_;
}
inline ::pg_query::List* Node::mutable_list() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.list)
  return _internal_mutable_list();
}

// .pg_query.IntList int_list = 227 [json_name = "IntList"];
inline bool Node::_internal_has_int_list() const {
  return node_case() == kIntList;
}
inline bool Node::has_int_list() const {
  return _internal_has_int_list();
}
inline void Node::set_has_int_list() {
  _oneof_case_[0] = kIntList;
}
inline void Node::clear_int_list() {
  if (_internal_has_int_list()) {
    if (GetArena() == nullptr) {
      delete node_.int_list_;
    }
    clear_has_node();
  }
}
inline ::pg_query::IntList* Node::release_int_list() {
  // @@protoc_insertion_point(field_release:pg_query.Node.int_list)
  if (_internal_has_int_list()) {
    clear_has_node();
      ::pg_query::IntList* temp = node_.int_list_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.int_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::IntList& Node::_internal_int_list() const {
  return _internal_has_int_list()
      ? *node_.int_list_
      : reinterpret_cast< ::pg_query::IntList&>(::pg_query::_IntList_default_instance_);
}
inline const ::pg_query::IntList& Node::int_list() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.int_list)
  return _internal_int_list();
}
inline ::pg_query::IntList* Node::unsafe_arena_release_int_list() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.int_list)
  if (_internal_has_int_list()) {
    clear_has_node();
    ::pg_query::IntList* temp = node_.int_list_;
    node_.int_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_int_list(::pg_query::IntList* int_list) {
  clear_node();
  if (int_list) {
    set_has_int_list();
    node_.int_list_ = int_list;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.int_list)
}
inline ::pg_query::IntList* Node::_internal_mutable_int_list() {
  if (!_internal_has_int_list()) {
    clear_node();
    set_has_int_list();
    node_.int_list_ = CreateMaybeMessage< ::pg_query::IntList >(GetArena());
  }
  return node_.int_list_;
}
inline ::pg_query::IntList* Node::mutable_int_list() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.int_list)
  return _internal_mutable_int_list();
}

// .pg_query.OidList oid_list = 228 [json_name = "OidList"];
inline bool Node::_internal_has_oid_list() const {
  return node_case() == kOidList;
}
inline bool Node::has_oid_list() const {
  return _internal_has_oid_list();
}
inline void Node::set_has_oid_list() {
  _oneof_case_[0] = kOidList;
}
inline void Node::clear_oid_list() {
  if (_internal_has_oid_list()) {
    if (GetArena() == nullptr) {
      delete node_.oid_list_;
    }
    clear_has_node();
  }
}
inline ::pg_query::OidList* Node::release_oid_list() {
  // @@protoc_insertion_point(field_release:pg_query.Node.oid_list)
  if (_internal_has_oid_list()) {
    clear_has_node();
      ::pg_query::OidList* temp = node_.oid_list_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    node_.oid_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::OidList& Node::_internal_oid_list() const {
  return _internal_has_oid_list()
      ? *node_.oid_list_
      : reinterpret_cast< ::pg_query::OidList&>(::pg_query::_OidList_default_instance_);
}
inline const ::pg_query::OidList& Node::oid_list() const {
  // @@protoc_insertion_point(field_get:pg_query.Node.oid_list)
  return _internal_oid_list();
}
inline ::pg_query::OidList* Node::unsafe_arena_release_oid_list() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.oid_list)
  if (_internal_has_oid_list()) {
    clear_has_node();
    ::pg_query::OidList* temp = node_.oid_list_;
    node_.oid_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_oid_list(::pg_query::OidList* oid_list) {
  clear_node();
  if (oid_list) {
    set_has_oid_list();
    node_.oid_list_ = oid_list;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.oid_list)
}
inline ::pg_query::OidList* Node::_internal_mutable_oid_list() {
  if (!_internal_has_oid_list()) {
    clear_node();
    set_has_oid_list();
    node_.oid_list_ = CreateMaybeMessage< ::pg_query::OidList >(GetArena());
  }
  return node_.oid_list_;
}
inline ::pg_query::OidList* Node::mutable_oid_list() {
  // @@protoc_insertion_point(field_mutable:pg_query.Node.oid_list)
  return _internal_mutable_oid_list();
}

inline bool Node::has_node() const {
  return node_case() != NODE_NOT_SET;
}
inline void Node::clear_has_node() {
  _oneof_case_[0] = NODE_NOT_SET;
}
inline Node::NodeCase Node::node_case() const {
  return Node::NodeCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// Integer

// int32 ival = 1;
inline void Integer::clear_ival() {
  ival_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Integer::_internal_ival() const {
  return ival_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Integer::ival() const {
  // @@protoc_insertion_point(field_get:pg_query.Integer.ival)
  return _internal_ival();
}
inline void Integer::_internal_set_ival(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  ival_ = value;
}
inline void Integer::set_ival(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_ival(value);
  // @@protoc_insertion_point(field_set:pg_query.Integer.ival)
}

// -------------------------------------------------------------------

// Float

// string str = 1;
inline void Float::clear_str() {
  str_.ClearToEmpty();
}
inline const std::string& Float::str() const {
  // @@protoc_insertion_point(field_get:pg_query.Float.str)
  return _internal_str();
}
inline void Float::set_str(const std::string& value) {
  _internal_set_str(value);
  // @@protoc_insertion_point(field_set:pg_query.Float.str)
}
inline std::string* Float::mutable_str() {
  // @@protoc_insertion_point(field_mutable:pg_query.Float.str)
  return _internal_mutable_str();
}
inline const std::string& Float::_internal_str() const {
  return str_.Get();
}
inline void Float::_internal_set_str(const std::string& value) {
  
  str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Float::set_str(std::string&& value) {
  
  str_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.Float.str)
}
inline void Float::set_str(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.Float.str)
}
inline void Float::set_str(const char* value,
    size_t size) {
  
  str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.Float.str)
}
inline std::string* Float::_internal_mutable_str() {
  
  return str_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Float::release_str() {
  // @@protoc_insertion_point(field_release:pg_query.Float.str)
  return str_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Float::set_allocated_str(std::string* str) {
  if (str != nullptr) {
    
  } else {
    
  }
  str_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), str,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.Float.str)
}

// -------------------------------------------------------------------

// String

// string str = 1;
inline void String::clear_str() {
  str_.ClearToEmpty();
}
inline const std::string& String::str() const {
  // @@protoc_insertion_point(field_get:pg_query.String.str)
  return _internal_str();
}
inline void String::set_str(const std::string& value) {
  _internal_set_str(value);
  // @@protoc_insertion_point(field_set:pg_query.String.str)
}
inline std::string* String::mutable_str() {
  // @@protoc_insertion_point(field_mutable:pg_query.String.str)
  return _internal_mutable_str();
}
inline const std::string& String::_internal_str() const {
  return str_.Get();
}
inline void String::_internal_set_str(const std::string& value) {
  
  str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void String::set_str(std::string&& value) {
  
  str_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.String.str)
}
inline void String::set_str(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.String.str)
}
inline void String::set_str(const char* value,
    size_t size) {
  
  str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.String.str)
}
inline std::string* String::_internal_mutable_str() {
  
  return str_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* String::release_str() {
  // @@protoc_insertion_point(field_release:pg_query.String.str)
  return str_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void String::set_allocated_str(std::string* str) {
  if (str != nullptr) {
    
  } else {
    
  }
  str_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), str,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.String.str)
}

// -------------------------------------------------------------------

// BitString

// string str = 1;
inline void BitString::clear_str() {
  str_.ClearToEmpty();
}
inline const std::string& BitString::str() const {
  // @@protoc_insertion_point(field_get:pg_query.BitString.str)
  return _internal_str();
}
inline void BitString::set_str(const std::string& value) {
  _internal_set_str(value);
  // @@protoc_insertion_point(field_set:pg_query.BitString.str)
}
inline std::string* BitString::mutable_str() {
  // @@protoc_insertion_point(field_mutable:pg_query.BitString.str)
  return _internal_mutable_str();
}
inline const std::string& BitString::_internal_str() const {
  return str_.Get();
}
inline void BitString::_internal_set_str(const std::string& value) {
  
  str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void BitString::set_str(std::string&& value) {
  
  str_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.BitString.str)
}
inline void BitString::set_str(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.BitString.str)
}
inline void BitString::set_str(const char* value,
    size_t size) {
  
  str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.BitString.str)
}
inline std::string* BitString::_internal_mutable_str() {
  
  return str_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* BitString::release_str() {
  // @@protoc_insertion_point(field_release:pg_query.BitString.str)
  return str_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void BitString::set_allocated_str(std::string* str) {
  if (str != nullptr) {
    
  } else {
    
  }
  str_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), str,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.BitString.str)
}

// -------------------------------------------------------------------

// Null

// -------------------------------------------------------------------

// List

// repeated .pg_query.Node items = 1;
inline int List::_internal_items_size() const {
  return items_.size();
}
inline int List::items_size() const {
  return _internal_items_size();
}
inline void List::clear_items() {
  items_.Clear();
}
inline ::pg_query::Node* List::mutable_items(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.List.items)
  return items_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
List::mutable_items() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.List.items)
  return &items_;
}
inline const ::pg_query::Node& List::_internal_items(int index) const {
  return items_.Get(index);
}
inline const ::pg_query::Node& List::items(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.List.items)
  return _internal_items(index);
}
inline ::pg_query::Node* List::_internal_add_items() {
  return items_.Add();
}
inline ::pg_query::Node* List::add_items() {
  // @@protoc_insertion_point(field_add:pg_query.List.items)
  return _internal_add_items();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
List::items() const {
  // @@protoc_insertion_point(field_list:pg_query.List.items)
  return items_;
}

// -------------------------------------------------------------------

// OidList

// repeated .pg_query.Node items = 1;
inline int OidList::_internal_items_size() const {
  return items_.size();
}
inline int OidList::items_size() const {
  return _internal_items_size();
}
inline void OidList::clear_items() {
  items_.Clear();
}
inline ::pg_query::Node* OidList::mutable_items(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.OidList.items)
  return items_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
OidList::mutable_items() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.OidList.items)
  return &items_;
}
inline const ::pg_query::Node& OidList::_internal_items(int index) const {
  return items_.Get(index);
}
inline const ::pg_query::Node& OidList::items(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.OidList.items)
  return _internal_items(index);
}
inline ::pg_query::Node* OidList::_internal_add_items() {
  return items_.Add();
}
inline ::pg_query::Node* OidList::add_items() {
  // @@protoc_insertion_point(field_add:pg_query.OidList.items)
  return _internal_add_items();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
OidList::items() const {
  // @@protoc_insertion_point(field_list:pg_query.OidList.items)
  return items_;
}

// -------------------------------------------------------------------

// IntList

// repeated .pg_query.Node items = 1;
inline int IntList::_internal_items_size() const {
  return items_.size();
}
inline int IntList::items_size() const {
  return _internal_items_size();
}
inline void IntList::clear_items() {
  items_.Clear();
}
inline ::pg_query::Node* IntList::mutable_items(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.IntList.items)
  return items_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
IntList::mutable_items() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IntList.items)
  return &items_;
}
inline const ::pg_query::Node& IntList::_internal_items(int index) const {
  return items_.Get(index);
}
inline const ::pg_query::Node& IntList::items(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.IntList.items)
  return _internal_items(index);
}
inline ::pg_query::Node* IntList::_internal_add_items() {
  return items_.Add();
}
inline ::pg_query::Node* IntList::add_items() {
  // @@protoc_insertion_point(field_add:pg_query.IntList.items)
  return _internal_add_items();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
IntList::items() const {
  // @@protoc_insertion_point(field_list:pg_query.IntList.items)
  return items_;
}

// -------------------------------------------------------------------

// Bitmapset

// repeated uint64 words = 1;
inline int Bitmapset::_internal_words_size() const {
  return words_.size();
}
inline int Bitmapset::words_size() const {
  return _internal_words_size();
}
inline void Bitmapset::clear_words() {
  words_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Bitmapset::_internal_words(int index) const {
  return words_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Bitmapset::words(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Bitmapset.words)
  return _internal_words(index);
}
inline void Bitmapset::set_words(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value) {
  words_.Set(index, value);
  // @@protoc_insertion_point(field_set:pg_query.Bitmapset.words)
}
inline void Bitmapset::_internal_add_words(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  words_.Add(value);
}
inline void Bitmapset::add_words(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_add_words(value);
  // @@protoc_insertion_point(field_add:pg_query.Bitmapset.words)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
Bitmapset::_internal_words() const {
  return words_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
Bitmapset::words() const {
  // @@protoc_insertion_point(field_list:pg_query.Bitmapset.words)
  return _internal_words();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
Bitmapset::_internal_mutable_words() {
  return &words_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
Bitmapset::mutable_words() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Bitmapset.words)
  return _internal_mutable_words();
}

// -------------------------------------------------------------------

// Alias

// string aliasname = 1 [json_name = "aliasname"];
inline void Alias::clear_aliasname() {
  aliasname_.ClearToEmpty();
}
inline const std::string& Alias::aliasname() const {
  // @@protoc_insertion_point(field_get:pg_query.Alias.aliasname)
  return _internal_aliasname();
}
inline void Alias::set_aliasname(const std::string& value) {
  _internal_set_aliasname(value);
  // @@protoc_insertion_point(field_set:pg_query.Alias.aliasname)
}
inline std::string* Alias::mutable_aliasname() {
  // @@protoc_insertion_point(field_mutable:pg_query.Alias.aliasname)
  return _internal_mutable_aliasname();
}
inline const std::string& Alias::_internal_aliasname() const {
  return aliasname_.Get();
}
inline void Alias::_internal_set_aliasname(const std::string& value) {
  
  aliasname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Alias::set_aliasname(std::string&& value) {
  
  aliasname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.Alias.aliasname)
}
inline void Alias::set_aliasname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  aliasname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.Alias.aliasname)
}
inline void Alias::set_aliasname(const char* value,
    size_t size) {
  
  aliasname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.Alias.aliasname)
}
inline std::string* Alias::_internal_mutable_aliasname() {
  
  return aliasname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Alias::release_aliasname() {
  // @@protoc_insertion_point(field_release:pg_query.Alias.aliasname)
  return aliasname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Alias::set_allocated_aliasname(std::string* aliasname) {
  if (aliasname != nullptr) {
    
  } else {
    
  }
  aliasname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), aliasname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.Alias.aliasname)
}

// repeated .pg_query.Node colnames = 2 [json_name = "colnames"];
inline int Alias::_internal_colnames_size() const {
  return colnames_.size();
}
inline int Alias::colnames_size() const {
  return _internal_colnames_size();
}
inline void Alias::clear_colnames() {
  colnames_.Clear();
}
inline ::pg_query::Node* Alias::mutable_colnames(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Alias.colnames)
  return colnames_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Alias::mutable_colnames() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Alias.colnames)
  return &colnames_;
}
inline const ::pg_query::Node& Alias::_internal_colnames(int index) const {
  return colnames_.Get(index);
}
inline const ::pg_query::Node& Alias::colnames(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Alias.colnames)
  return _internal_colnames(index);
}
inline ::pg_query::Node* Alias::_internal_add_colnames() {
  return colnames_.Add();
}
inline ::pg_query::Node* Alias::add_colnames() {
  // @@protoc_insertion_point(field_add:pg_query.Alias.colnames)
  return _internal_add_colnames();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Alias::colnames() const {
  // @@protoc_insertion_point(field_list:pg_query.Alias.colnames)
  return colnames_;
}

// -------------------------------------------------------------------

// RangeVar

// string catalogname = 1 [json_name = "catalogname"];
inline void RangeVar::clear_catalogname() {
  catalogname_.ClearToEmpty();
}
inline const std::string& RangeVar::catalogname() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.catalogname)
  return _internal_catalogname();
}
inline void RangeVar::set_catalogname(const std::string& value) {
  _internal_set_catalogname(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeVar.catalogname)
}
inline std::string* RangeVar::mutable_catalogname() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeVar.catalogname)
  return _internal_mutable_catalogname();
}
inline const std::string& RangeVar::_internal_catalogname() const {
  return catalogname_.Get();
}
inline void RangeVar::_internal_set_catalogname(const std::string& value) {
  
  catalogname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RangeVar::set_catalogname(std::string&& value) {
  
  catalogname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.RangeVar.catalogname)
}
inline void RangeVar::set_catalogname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  catalogname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.RangeVar.catalogname)
}
inline void RangeVar::set_catalogname(const char* value,
    size_t size) {
  
  catalogname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.RangeVar.catalogname)
}
inline std::string* RangeVar::_internal_mutable_catalogname() {
  
  return catalogname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RangeVar::release_catalogname() {
  // @@protoc_insertion_point(field_release:pg_query.RangeVar.catalogname)
  return catalogname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RangeVar::set_allocated_catalogname(std::string* catalogname) {
  if (catalogname != nullptr) {
    
  } else {
    
  }
  catalogname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), catalogname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeVar.catalogname)
}

// string schemaname = 2 [json_name = "schemaname"];
inline void RangeVar::clear_schemaname() {
  schemaname_.ClearToEmpty();
}
inline const std::string& RangeVar::schemaname() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.schemaname)
  return _internal_schemaname();
}
inline void RangeVar::set_schemaname(const std::string& value) {
  _internal_set_schemaname(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeVar.schemaname)
}
inline std::string* RangeVar::mutable_schemaname() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeVar.schemaname)
  return _internal_mutable_schemaname();
}
inline const std::string& RangeVar::_internal_schemaname() const {
  return schemaname_.Get();
}
inline void RangeVar::_internal_set_schemaname(const std::string& value) {
  
  schemaname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RangeVar::set_schemaname(std::string&& value) {
  
  schemaname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.RangeVar.schemaname)
}
inline void RangeVar::set_schemaname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  schemaname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.RangeVar.schemaname)
}
inline void RangeVar::set_schemaname(const char* value,
    size_t size) {
  
  schemaname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.RangeVar.schemaname)
}
inline std::string* RangeVar::_internal_mutable_schemaname() {
  
  return schemaname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RangeVar::release_schemaname() {
  // @@protoc_insertion_point(field_release:pg_query.RangeVar.schemaname)
  return schemaname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RangeVar::set_allocated_schemaname(std::string* schemaname) {
  if (schemaname != nullptr) {
    
  } else {
    
  }
  schemaname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), schemaname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeVar.schemaname)
}

// string relname = 3 [json_name = "relname"];
inline void RangeVar::clear_relname() {
  relname_.ClearToEmpty();
}
inline const std::string& RangeVar::relname() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.relname)
  return _internal_relname();
}
inline void RangeVar::set_relname(const std::string& value) {
  _internal_set_relname(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeVar.relname)
}
inline std::string* RangeVar::mutable_relname() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeVar.relname)
  return _internal_mutable_relname();
}
inline const std::string& RangeVar::_internal_relname() const {
  return relname_.Get();
}
inline void RangeVar::_internal_set_relname(const std::string& value) {
  
  relname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RangeVar::set_relname(std::string&& value) {
  
  relname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.RangeVar.relname)
}
inline void RangeVar::set_relname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  relname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.RangeVar.relname)
}
inline void RangeVar::set_relname(const char* value,
    size_t size) {
  
  relname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.RangeVar.relname)
}
inline std::string* RangeVar::_internal_mutable_relname() {
  
  return relname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RangeVar::release_relname() {
  // @@protoc_insertion_point(field_release:pg_query.RangeVar.relname)
  return relname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RangeVar::set_allocated_relname(std::string* relname) {
  if (relname != nullptr) {
    
  } else {
    
  }
  relname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), relname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeVar.relname)
}

// bool inh = 4 [json_name = "inh"];
inline void RangeVar::clear_inh() {
  inh_ = false;
}
inline bool RangeVar::_internal_inh() const {
  return inh_;
}
inline bool RangeVar::inh() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.inh)
  return _internal_inh();
}
inline void RangeVar::_internal_set_inh(bool value) {
  
  inh_ = value;
}
inline void RangeVar::set_inh(bool value) {
  _internal_set_inh(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeVar.inh)
}

// string relpersistence = 5 [json_name = "relpersistence"];
inline void RangeVar::clear_relpersistence() {
  relpersistence_.ClearToEmpty();
}
inline const std::string& RangeVar::relpersistence() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.relpersistence)
  return _internal_relpersistence();
}
inline void RangeVar::set_relpersistence(const std::string& value) {
  _internal_set_relpersistence(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeVar.relpersistence)
}
inline std::string* RangeVar::mutable_relpersistence() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeVar.relpersistence)
  return _internal_mutable_relpersistence();
}
inline const std::string& RangeVar::_internal_relpersistence() const {
  return relpersistence_.Get();
}
inline void RangeVar::_internal_set_relpersistence(const std::string& value) {
  
  relpersistence_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RangeVar::set_relpersistence(std::string&& value) {
  
  relpersistence_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.RangeVar.relpersistence)
}
inline void RangeVar::set_relpersistence(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  relpersistence_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.RangeVar.relpersistence)
}
inline void RangeVar::set_relpersistence(const char* value,
    size_t size) {
  
  relpersistence_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.RangeVar.relpersistence)
}
inline std::string* RangeVar::_internal_mutable_relpersistence() {
  
  return relpersistence_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RangeVar::release_relpersistence() {
  // @@protoc_insertion_point(field_release:pg_query.RangeVar.relpersistence)
  return relpersistence_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RangeVar::set_allocated_relpersistence(std::string* relpersistence) {
  if (relpersistence != nullptr) {
    
  } else {
    
  }
  relpersistence_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), relpersistence,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeVar.relpersistence)
}

// .pg_query.Alias alias = 6 [json_name = "alias"];
inline bool RangeVar::_internal_has_alias() const {
  return this != internal_default_instance() && alias_ != nullptr;
}
inline bool RangeVar::has_alias() const {
  return _internal_has_alias();
}
inline void RangeVar::clear_alias() {
  if (GetArena() == nullptr && alias_ != nullptr) {
    delete alias_;
  }
  alias_ = nullptr;
}
inline const ::pg_query::Alias& RangeVar::_internal_alias() const {
  const ::pg_query::Alias* p = alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(
      ::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& RangeVar::alias() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.alias)
  return _internal_alias();
}
inline void RangeVar::unsafe_arena_set_allocated_alias(
    ::pg_query::Alias* alias) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alias_);
  }
  alias_ = alias;
  if (alias) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeVar.alias)
}
inline ::pg_query::Alias* RangeVar::release_alias() {
  
  ::pg_query::Alias* temp = alias_;
  alias_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Alias* RangeVar::unsafe_arena_release_alias() {
  // @@protoc_insertion_point(field_release:pg_query.RangeVar.alias)
  
  ::pg_query::Alias* temp = alias_;
  alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* RangeVar::_internal_mutable_alias() {
  
  if (alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    alias_ = p;
  }
  return alias_;
}
inline ::pg_query::Alias* RangeVar::mutable_alias() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeVar.alias)
  return _internal_mutable_alias();
}
inline void RangeVar::set_allocated_alias(::pg_query::Alias* alias) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete alias_;
  }
  if (alias) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(alias);
    if (message_arena != submessage_arena) {
      alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, alias, submessage_arena);
    }
    
  } else {
    
  }
  alias_ = alias;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeVar.alias)
}

// int32 location = 7 [json_name = "location"];
inline void RangeVar::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeVar::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeVar::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.location)
  return _internal_location();
}
inline void RangeVar::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void RangeVar::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeVar.location)
}

// -------------------------------------------------------------------

// TableFunc

// repeated .pg_query.Node ns_uris = 1 [json_name = "ns_uris"];
inline int TableFunc::_internal_ns_uris_size() const {
  return ns_uris_.size();
}
inline int TableFunc::ns_uris_size() const {
  return _internal_ns_uris_size();
}
inline void TableFunc::clear_ns_uris() {
  ns_uris_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_ns_uris(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.ns_uris)
  return ns_uris_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TableFunc::mutable_ns_uris() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.ns_uris)
  return &ns_uris_;
}
inline const ::pg_query::Node& TableFunc::_internal_ns_uris(int index) const {
  return ns_uris_.Get(index);
}
inline const ::pg_query::Node& TableFunc::ns_uris(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.ns_uris)
  return _internal_ns_uris(index);
}
inline ::pg_query::Node* TableFunc::_internal_add_ns_uris() {
  return ns_uris_.Add();
}
inline ::pg_query::Node* TableFunc::add_ns_uris() {
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.ns_uris)
  return _internal_add_ns_uris();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TableFunc::ns_uris() const {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.ns_uris)
  return ns_uris_;
}

// repeated .pg_query.Node ns_names = 2 [json_name = "ns_names"];
inline int TableFunc::_internal_ns_names_size() const {
  return ns_names_.size();
}
inline int TableFunc::ns_names_size() const {
  return _internal_ns_names_size();
}
inline void TableFunc::clear_ns_names() {
  ns_names_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_ns_names(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.ns_names)
  return ns_names_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TableFunc::mutable_ns_names() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.ns_names)
  return &ns_names_;
}
inline const ::pg_query::Node& TableFunc::_internal_ns_names(int index) const {
  return ns_names_.Get(index);
}
inline const ::pg_query::Node& TableFunc::ns_names(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.ns_names)
  return _internal_ns_names(index);
}
inline ::pg_query::Node* TableFunc::_internal_add_ns_names() {
  return ns_names_.Add();
}
inline ::pg_query::Node* TableFunc::add_ns_names() {
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.ns_names)
  return _internal_add_ns_names();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TableFunc::ns_names() const {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.ns_names)
  return ns_names_;
}

// .pg_query.Node docexpr = 3 [json_name = "docexpr"];
inline bool TableFunc::_internal_has_docexpr() const {
  return this != internal_default_instance() && docexpr_ != nullptr;
}
inline bool TableFunc::has_docexpr() const {
  return _internal_has_docexpr();
}
inline void TableFunc::clear_docexpr() {
  if (GetArena() == nullptr && docexpr_ != nullptr) {
    delete docexpr_;
  }
  docexpr_ = nullptr;
}
inline const ::pg_query::Node& TableFunc::_internal_docexpr() const {
  const ::pg_query::Node* p = docexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& TableFunc::docexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.docexpr)
  return _internal_docexpr();
}
inline void TableFunc::unsafe_arena_set_allocated_docexpr(
    ::pg_query::Node* docexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(docexpr_);
  }
  docexpr_ = docexpr;
  if (docexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TableFunc.docexpr)
}
inline ::pg_query::Node* TableFunc::release_docexpr() {
  
  ::pg_query::Node* temp = docexpr_;
  docexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* TableFunc::unsafe_arena_release_docexpr() {
  // @@protoc_insertion_point(field_release:pg_query.TableFunc.docexpr)
  
  ::pg_query::Node* temp = docexpr_;
  docexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* TableFunc::_internal_mutable_docexpr() {
  
  if (docexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    docexpr_ = p;
  }
  return docexpr_;
}
inline ::pg_query::Node* TableFunc::mutable_docexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.docexpr)
  return _internal_mutable_docexpr();
}
inline void TableFunc::set_allocated_docexpr(::pg_query::Node* docexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete docexpr_;
  }
  if (docexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(docexpr);
    if (message_arena != submessage_arena) {
      docexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, docexpr, submessage_arena);
    }
    
  } else {
    
  }
  docexpr_ = docexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.TableFunc.docexpr)
}

// .pg_query.Node rowexpr = 4 [json_name = "rowexpr"];
inline bool TableFunc::_internal_has_rowexpr() const {
  return this != internal_default_instance() && rowexpr_ != nullptr;
}
inline bool TableFunc::has_rowexpr() const {
  return _internal_has_rowexpr();
}
inline void TableFunc::clear_rowexpr() {
  if (GetArena() == nullptr && rowexpr_ != nullptr) {
    delete rowexpr_;
  }
  rowexpr_ = nullptr;
}
inline const ::pg_query::Node& TableFunc::_internal_rowexpr() const {
  const ::pg_query::Node* p = rowexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& TableFunc::rowexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.rowexpr)
  return _internal_rowexpr();
}
inline void TableFunc::unsafe_arena_set_allocated_rowexpr(
    ::pg_query::Node* rowexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rowexpr_);
  }
  rowexpr_ = rowexpr;
  if (rowexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TableFunc.rowexpr)
}
inline ::pg_query::Node* TableFunc::release_rowexpr() {
  
  ::pg_query::Node* temp = rowexpr_;
  rowexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* TableFunc::unsafe_arena_release_rowexpr() {
  // @@protoc_insertion_point(field_release:pg_query.TableFunc.rowexpr)
  
  ::pg_query::Node* temp = rowexpr_;
  rowexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* TableFunc::_internal_mutable_rowexpr() {
  
  if (rowexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    rowexpr_ = p;
  }
  return rowexpr_;
}
inline ::pg_query::Node* TableFunc::mutable_rowexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.rowexpr)
  return _internal_mutable_rowexpr();
}
inline void TableFunc::set_allocated_rowexpr(::pg_query::Node* rowexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete rowexpr_;
  }
  if (rowexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(rowexpr);
    if (message_arena != submessage_arena) {
      rowexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rowexpr, submessage_arena);
    }
    
  } else {
    
  }
  rowexpr_ = rowexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.TableFunc.rowexpr)
}

// repeated .pg_query.Node colnames = 5 [json_name = "colnames"];
inline int TableFunc::_internal_colnames_size() const {
  return colnames_.size();
}
inline int TableFunc::colnames_size() const {
  return _internal_colnames_size();
}
inline void TableFunc::clear_colnames() {
  colnames_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_colnames(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.colnames)
  return colnames_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TableFunc::mutable_colnames() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.colnames)
  return &colnames_;
}
inline const ::pg_query::Node& TableFunc::_internal_colnames(int index) const {
  return colnames_.Get(index);
}
inline const ::pg_query::Node& TableFunc::colnames(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.colnames)
  return _internal_colnames(index);
}
inline ::pg_query::Node* TableFunc::_internal_add_colnames() {
  return colnames_.Add();
}
inline ::pg_query::Node* TableFunc::add_colnames() {
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.colnames)
  return _internal_add_colnames();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TableFunc::colnames() const {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.colnames)
  return colnames_;
}

// repeated .pg_query.Node coltypes = 6 [json_name = "coltypes"];
inline int TableFunc::_internal_coltypes_size() const {
  return coltypes_.size();
}
inline int TableFunc::coltypes_size() const {
  return _internal_coltypes_size();
}
inline void TableFunc::clear_coltypes() {
  coltypes_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_coltypes(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.coltypes)
  return coltypes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TableFunc::mutable_coltypes() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.coltypes)
  return &coltypes_;
}
inline const ::pg_query::Node& TableFunc::_internal_coltypes(int index) const {
  return coltypes_.Get(index);
}
inline const ::pg_query::Node& TableFunc::coltypes(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.coltypes)
  return _internal_coltypes(index);
}
inline ::pg_query::Node* TableFunc::_internal_add_coltypes() {
  return coltypes_.Add();
}
inline ::pg_query::Node* TableFunc::add_coltypes() {
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.coltypes)
  return _internal_add_coltypes();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TableFunc::coltypes() const {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.coltypes)
  return coltypes_;
}

// repeated .pg_query.Node coltypmods = 7 [json_name = "coltypmods"];
inline int TableFunc::_internal_coltypmods_size() const {
  return coltypmods_.size();
}
inline int TableFunc::coltypmods_size() const {
  return _internal_coltypmods_size();
}
inline void TableFunc::clear_coltypmods() {
  coltypmods_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_coltypmods(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.coltypmods)
  return coltypmods_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TableFunc::mutable_coltypmods() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.coltypmods)
  return &coltypmods_;
}
inline const ::pg_query::Node& TableFunc::_internal_coltypmods(int index) const {
  return coltypmods_.Get(index);
}
inline const ::pg_query::Node& TableFunc::coltypmods(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.coltypmods)
  return _internal_coltypmods(index);
}
inline ::pg_query::Node* TableFunc::_internal_add_coltypmods() {
  return coltypmods_.Add();
}
inline ::pg_query::Node* TableFunc::add_coltypmods() {
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.coltypmods)
  return _internal_add_coltypmods();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TableFunc::coltypmods() const {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.coltypmods)
  return coltypmods_;
}

// repeated .pg_query.Node colcollations = 8 [json_name = "colcollations"];
inline int TableFunc::_internal_colcollations_size() const {
  return colcollations_.size();
}
inline int TableFunc::colcollations_size() const {
  return _internal_colcollations_size();
}
inline void TableFunc::clear_colcollations() {
  colcollations_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_colcollations(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.colcollations)
  return colcollations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TableFunc::mutable_colcollations() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.colcollations)
  return &colcollations_;
}
inline const ::pg_query::Node& TableFunc::_internal_colcollations(int index) const {
  return colcollations_.Get(index);
}
inline const ::pg_query::Node& TableFunc::colcollations(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.colcollations)
  return _internal_colcollations(index);
}
inline ::pg_query::Node* TableFunc::_internal_add_colcollations() {
  return colcollations_.Add();
}
inline ::pg_query::Node* TableFunc::add_colcollations() {
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.colcollations)
  return _internal_add_colcollations();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TableFunc::colcollations() const {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.colcollations)
  return colcollations_;
}

// repeated .pg_query.Node colexprs = 9 [json_name = "colexprs"];
inline int TableFunc::_internal_colexprs_size() const {
  return colexprs_.size();
}
inline int TableFunc::colexprs_size() const {
  return _internal_colexprs_size();
}
inline void TableFunc::clear_colexprs() {
  colexprs_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_colexprs(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.colexprs)
  return colexprs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TableFunc::mutable_colexprs() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.colexprs)
  return &colexprs_;
}
inline const ::pg_query::Node& TableFunc::_internal_colexprs(int index) const {
  return colexprs_.Get(index);
}
inline const ::pg_query::Node& TableFunc::colexprs(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.colexprs)
  return _internal_colexprs(index);
}
inline ::pg_query::Node* TableFunc::_internal_add_colexprs() {
  return colexprs_.Add();
}
inline ::pg_query::Node* TableFunc::add_colexprs() {
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.colexprs)
  return _internal_add_colexprs();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TableFunc::colexprs() const {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.colexprs)
  return colexprs_;
}

// repeated .pg_query.Node coldefexprs = 10 [json_name = "coldefexprs"];
inline int TableFunc::_internal_coldefexprs_size() const {
  return coldefexprs_.size();
}
inline int TableFunc::coldefexprs_size() const {
  return _internal_coldefexprs_size();
}
inline void TableFunc::clear_coldefexprs() {
  coldefexprs_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_coldefexprs(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.coldefexprs)
  return coldefexprs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TableFunc::mutable_coldefexprs() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.coldefexprs)
  return &coldefexprs_;
}
inline const ::pg_query::Node& TableFunc::_internal_coldefexprs(int index) const {
  return coldefexprs_.Get(index);
}
inline const ::pg_query::Node& TableFunc::coldefexprs(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.coldefexprs)
  return _internal_coldefexprs(index);
}
inline ::pg_query::Node* TableFunc::_internal_add_coldefexprs() {
  return coldefexprs_.Add();
}
inline ::pg_query::Node* TableFunc::add_coldefexprs() {
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.coldefexprs)
  return _internal_add_coldefexprs();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TableFunc::coldefexprs() const {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.coldefexprs)
  return coldefexprs_;
}

// int32 ordinalitycol = 11 [json_name = "ordinalitycol"];
inline void TableFunc::clear_ordinalitycol() {
  ordinalitycol_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TableFunc::_internal_ordinalitycol() const {
  return ordinalitycol_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TableFunc::ordinalitycol() const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.ordinalitycol)
  return _internal_ordinalitycol();
}
inline void TableFunc::_internal_set_ordinalitycol(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  ordinalitycol_ = value;
}
inline void TableFunc::set_ordinalitycol(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_ordinalitycol(value);
  // @@protoc_insertion_point(field_set:pg_query.TableFunc.ordinalitycol)
}

// int32 location = 12 [json_name = "location"];
inline void TableFunc::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TableFunc::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TableFunc::location() const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.location)
  return _internal_location();
}
inline void TableFunc::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void TableFunc::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.TableFunc.location)
}

// -------------------------------------------------------------------

// Expr

// -------------------------------------------------------------------

// Var

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool Var::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool Var::has_xpr() const {
  return _internal_has_xpr();
}
inline void Var::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& Var::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Var::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.xpr)
  return _internal_xpr();
}
inline void Var::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Var.xpr)
}
inline ::pg_query::Node* Var::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* Var::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.Var.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Var::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* Var::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Var.xpr)
  return _internal_mutable_xpr();
}
inline void Var::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Var.xpr)
}

// uint32 varno = 2 [json_name = "varno"];
inline void Var::clear_varno() {
  varno_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Var::_internal_varno() const {
  return varno_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Var::varno() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.varno)
  return _internal_varno();
}
inline void Var::_internal_set_varno(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  varno_ = value;
}
inline void Var::set_varno(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_varno(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.varno)
}

// int32 varattno = 3 [json_name = "varattno"];
inline void Var::clear_varattno() {
  varattno_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Var::_internal_varattno() const {
  return varattno_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Var::varattno() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.varattno)
  return _internal_varattno();
}
inline void Var::_internal_set_varattno(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  varattno_ = value;
}
inline void Var::set_varattno(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_varattno(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.varattno)
}

// uint32 vartype = 4 [json_name = "vartype"];
inline void Var::clear_vartype() {
  vartype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Var::_internal_vartype() const {
  return vartype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Var::vartype() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.vartype)
  return _internal_vartype();
}
inline void Var::_internal_set_vartype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  vartype_ = value;
}
inline void Var::set_vartype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_vartype(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.vartype)
}

// int32 vartypmod = 5 [json_name = "vartypmod"];
inline void Var::clear_vartypmod() {
  vartypmod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Var::_internal_vartypmod() const {
  return vartypmod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Var::vartypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.vartypmod)
  return _internal_vartypmod();
}
inline void Var::_internal_set_vartypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  vartypmod_ = value;
}
inline void Var::set_vartypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_vartypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.vartypmod)
}

// uint32 varcollid = 6 [json_name = "varcollid"];
inline void Var::clear_varcollid() {
  varcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Var::_internal_varcollid() const {
  return varcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Var::varcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.varcollid)
  return _internal_varcollid();
}
inline void Var::_internal_set_varcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  varcollid_ = value;
}
inline void Var::set_varcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_varcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.varcollid)
}

// uint32 varlevelsup = 7 [json_name = "varlevelsup"];
inline void Var::clear_varlevelsup() {
  varlevelsup_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Var::_internal_varlevelsup() const {
  return varlevelsup_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Var::varlevelsup() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.varlevelsup)
  return _internal_varlevelsup();
}
inline void Var::_internal_set_varlevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  varlevelsup_ = value;
}
inline void Var::set_varlevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_varlevelsup(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.varlevelsup)
}

// uint32 varnosyn = 8 [json_name = "varnosyn"];
inline void Var::clear_varnosyn() {
  varnosyn_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Var::_internal_varnosyn() const {
  return varnosyn_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Var::varnosyn() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.varnosyn)
  return _internal_varnosyn();
}
inline void Var::_internal_set_varnosyn(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  varnosyn_ = value;
}
inline void Var::set_varnosyn(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_varnosyn(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.varnosyn)
}

// int32 varattnosyn = 9 [json_name = "varattnosyn"];
inline void Var::clear_varattnosyn() {
  varattnosyn_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Var::_internal_varattnosyn() const {
  return varattnosyn_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Var::varattnosyn() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.varattnosyn)
  return _internal_varattnosyn();
}
inline void Var::_internal_set_varattnosyn(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  varattnosyn_ = value;
}
inline void Var::set_varattnosyn(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_varattnosyn(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.varattnosyn)
}

// int32 location = 10 [json_name = "location"];
inline void Var::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Var::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Var::location() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.location)
  return _internal_location();
}
inline void Var::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void Var::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.location)
}

// -------------------------------------------------------------------

// Param

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool Param::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool Param::has_xpr() const {
  return _internal_has_xpr();
}
inline void Param::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& Param::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Param::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.Param.xpr)
  return _internal_xpr();
}
inline void Param::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Param.xpr)
}
inline ::pg_query::Node* Param::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* Param::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.Param.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Param::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* Param::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Param.xpr)
  return _internal_mutable_xpr();
}
inline void Param::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Param.xpr)
}

// .pg_query.ParamKind paramkind = 2 [json_name = "paramkind"];
inline void Param::clear_paramkind() {
  paramkind_ = 0;
}
inline ::pg_query::ParamKind Param::_internal_paramkind() const {
  return static_cast< ::pg_query::ParamKind >(paramkind_);
}
inline ::pg_query::ParamKind Param::paramkind() const {
  // @@protoc_insertion_point(field_get:pg_query.Param.paramkind)
  return _internal_paramkind();
}
inline void Param::_internal_set_paramkind(::pg_query::ParamKind value) {
  
  paramkind_ = value;
}
inline void Param::set_paramkind(::pg_query::ParamKind value) {
  _internal_set_paramkind(value);
  // @@protoc_insertion_point(field_set:pg_query.Param.paramkind)
}

// int32 paramid = 3 [json_name = "paramid"];
inline void Param::clear_paramid() {
  paramid_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Param::_internal_paramid() const {
  return paramid_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Param::paramid() const {
  // @@protoc_insertion_point(field_get:pg_query.Param.paramid)
  return _internal_paramid();
}
inline void Param::_internal_set_paramid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  paramid_ = value;
}
inline void Param::set_paramid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_paramid(value);
  // @@protoc_insertion_point(field_set:pg_query.Param.paramid)
}

// uint32 paramtype = 4 [json_name = "paramtype"];
inline void Param::clear_paramtype() {
  paramtype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Param::_internal_paramtype() const {
  return paramtype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Param::paramtype() const {
  // @@protoc_insertion_point(field_get:pg_query.Param.paramtype)
  return _internal_paramtype();
}
inline void Param::_internal_set_paramtype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  paramtype_ = value;
}
inline void Param::set_paramtype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_paramtype(value);
  // @@protoc_insertion_point(field_set:pg_query.Param.paramtype)
}

// int32 paramtypmod = 5 [json_name = "paramtypmod"];
inline void Param::clear_paramtypmod() {
  paramtypmod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Param::_internal_paramtypmod() const {
  return paramtypmod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Param::paramtypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.Param.paramtypmod)
  return _internal_paramtypmod();
}
inline void Param::_internal_set_paramtypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  paramtypmod_ = value;
}
inline void Param::set_paramtypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_paramtypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.Param.paramtypmod)
}

// uint32 paramcollid = 6 [json_name = "paramcollid"];
inline void Param::clear_paramcollid() {
  paramcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Param::_internal_paramcollid() const {
  return paramcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Param::paramcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.Param.paramcollid)
  return _internal_paramcollid();
}
inline void Param::_internal_set_paramcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  paramcollid_ = value;
}
inline void Param::set_paramcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_paramcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.Param.paramcollid)
}

// int32 location = 7 [json_name = "location"];
inline void Param::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Param::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Param::location() const {
  // @@protoc_insertion_point(field_get:pg_query.Param.location)
  return _internal_location();
}
inline void Param::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void Param::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.Param.location)
}

// -------------------------------------------------------------------

// Aggref

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool Aggref::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool Aggref::has_xpr() const {
  return _internal_has_xpr();
}
inline void Aggref::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& Aggref::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Aggref::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.xpr)
  return _internal_xpr();
}
inline void Aggref::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Aggref.xpr)
}
inline ::pg_query::Node* Aggref::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* Aggref::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.Aggref.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Aggref::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* Aggref::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.xpr)
  return _internal_mutable_xpr();
}
inline void Aggref::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Aggref.xpr)
}

// uint32 aggfnoid = 2 [json_name = "aggfnoid"];
inline void Aggref::clear_aggfnoid() {
  aggfnoid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Aggref::_internal_aggfnoid() const {
  return aggfnoid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Aggref::aggfnoid() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggfnoid)
  return _internal_aggfnoid();
}
inline void Aggref::_internal_set_aggfnoid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  aggfnoid_ = value;
}
inline void Aggref::set_aggfnoid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_aggfnoid(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggfnoid)
}

// uint32 aggtype = 3 [json_name = "aggtype"];
inline void Aggref::clear_aggtype() {
  aggtype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Aggref::_internal_aggtype() const {
  return aggtype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Aggref::aggtype() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggtype)
  return _internal_aggtype();
}
inline void Aggref::_internal_set_aggtype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  aggtype_ = value;
}
inline void Aggref::set_aggtype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_aggtype(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggtype)
}

// uint32 aggcollid = 4 [json_name = "aggcollid"];
inline void Aggref::clear_aggcollid() {
  aggcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Aggref::_internal_aggcollid() const {
  return aggcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Aggref::aggcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggcollid)
  return _internal_aggcollid();
}
inline void Aggref::_internal_set_aggcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  aggcollid_ = value;
}
inline void Aggref::set_aggcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_aggcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggcollid)
}

// uint32 inputcollid = 5 [json_name = "inputcollid"];
inline void Aggref::clear_inputcollid() {
  inputcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Aggref::_internal_inputcollid() const {
  return inputcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Aggref::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.inputcollid)
  return _internal_inputcollid();
}
inline void Aggref::_internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  inputcollid_ = value;
}
inline void Aggref::set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.inputcollid)
}

// uint32 aggtranstype = 6 [json_name = "aggtranstype"];
inline void Aggref::clear_aggtranstype() {
  aggtranstype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Aggref::_internal_aggtranstype() const {
  return aggtranstype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Aggref::aggtranstype() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggtranstype)
  return _internal_aggtranstype();
}
inline void Aggref::_internal_set_aggtranstype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  aggtranstype_ = value;
}
inline void Aggref::set_aggtranstype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_aggtranstype(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggtranstype)
}

// repeated .pg_query.Node aggargtypes = 7 [json_name = "aggargtypes"];
inline int Aggref::_internal_aggargtypes_size() const {
  return aggargtypes_.size();
}
inline int Aggref::aggargtypes_size() const {
  return _internal_aggargtypes_size();
}
inline void Aggref::clear_aggargtypes() {
  aggargtypes_.Clear();
}
inline ::pg_query::Node* Aggref::mutable_aggargtypes(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggargtypes)
  return aggargtypes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Aggref::mutable_aggargtypes() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.aggargtypes)
  return &aggargtypes_;
}
inline const ::pg_query::Node& Aggref::_internal_aggargtypes(int index) const {
  return aggargtypes_.Get(index);
}
inline const ::pg_query::Node& Aggref::aggargtypes(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggargtypes)
  return _internal_aggargtypes(index);
}
inline ::pg_query::Node* Aggref::_internal_add_aggargtypes() {
  return aggargtypes_.Add();
}
inline ::pg_query::Node* Aggref::add_aggargtypes() {
  // @@protoc_insertion_point(field_add:pg_query.Aggref.aggargtypes)
  return _internal_add_aggargtypes();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Aggref::aggargtypes() const {
  // @@protoc_insertion_point(field_list:pg_query.Aggref.aggargtypes)
  return aggargtypes_;
}

// repeated .pg_query.Node aggdirectargs = 8 [json_name = "aggdirectargs"];
inline int Aggref::_internal_aggdirectargs_size() const {
  return aggdirectargs_.size();
}
inline int Aggref::aggdirectargs_size() const {
  return _internal_aggdirectargs_size();
}
inline void Aggref::clear_aggdirectargs() {
  aggdirectargs_.Clear();
}
inline ::pg_query::Node* Aggref::mutable_aggdirectargs(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggdirectargs)
  return aggdirectargs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Aggref::mutable_aggdirectargs() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.aggdirectargs)
  return &aggdirectargs_;
}
inline const ::pg_query::Node& Aggref::_internal_aggdirectargs(int index) const {
  return aggdirectargs_.Get(index);
}
inline const ::pg_query::Node& Aggref::aggdirectargs(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggdirectargs)
  return _internal_aggdirectargs(index);
}
inline ::pg_query::Node* Aggref::_internal_add_aggdirectargs() {
  return aggdirectargs_.Add();
}
inline ::pg_query::Node* Aggref::add_aggdirectargs() {
  // @@protoc_insertion_point(field_add:pg_query.Aggref.aggdirectargs)
  return _internal_add_aggdirectargs();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Aggref::aggdirectargs() const {
  // @@protoc_insertion_point(field_list:pg_query.Aggref.aggdirectargs)
  return aggdirectargs_;
}

// repeated .pg_query.Node args = 9 [json_name = "args"];
inline int Aggref::_internal_args_size() const {
  return args_.size();
}
inline int Aggref::args_size() const {
  return _internal_args_size();
}
inline void Aggref::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* Aggref::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Aggref::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.args)
  return &args_;
}
inline const ::pg_query::Node& Aggref::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& Aggref::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.args)
  return _internal_args(index);
}
inline ::pg_query::Node* Aggref::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* Aggref::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.Aggref.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Aggref::args() const {
  // @@protoc_insertion_point(field_list:pg_query.Aggref.args)
  return args_;
}

// repeated .pg_query.Node aggorder = 10 [json_name = "aggorder"];
inline int Aggref::_internal_aggorder_size() const {
  return aggorder_.size();
}
inline int Aggref::aggorder_size() const {
  return _internal_aggorder_size();
}
inline void Aggref::clear_aggorder() {
  aggorder_.Clear();
}
inline ::pg_query::Node* Aggref::mutable_aggorder(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggorder)
  return aggorder_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Aggref::mutable_aggorder() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.aggorder)
  return &aggorder_;
}
inline const ::pg_query::Node& Aggref::_internal_aggorder(int index) const {
  return aggorder_.Get(index);
}
inline const ::pg_query::Node& Aggref::aggorder(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggorder)
  return _internal_aggorder(index);
}
inline ::pg_query::Node* Aggref::_internal_add_aggorder() {
  return aggorder_.Add();
}
inline ::pg_query::Node* Aggref::add_aggorder() {
  // @@protoc_insertion_point(field_add:pg_query.Aggref.aggorder)
  return _internal_add_aggorder();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Aggref::aggorder() const {
  // @@protoc_insertion_point(field_list:pg_query.Aggref.aggorder)
  return aggorder_;
}

// repeated .pg_query.Node aggdistinct = 11 [json_name = "aggdistinct"];
inline int Aggref::_internal_aggdistinct_size() const {
  return aggdistinct_.size();
}
inline int Aggref::aggdistinct_size() const {
  return _internal_aggdistinct_size();
}
inline void Aggref::clear_aggdistinct() {
  aggdistinct_.Clear();
}
inline ::pg_query::Node* Aggref::mutable_aggdistinct(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggdistinct)
  return aggdistinct_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Aggref::mutable_aggdistinct() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.aggdistinct)
  return &aggdistinct_;
}
inline const ::pg_query::Node& Aggref::_internal_aggdistinct(int index) const {
  return aggdistinct_.Get(index);
}
inline const ::pg_query::Node& Aggref::aggdistinct(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggdistinct)
  return _internal_aggdistinct(index);
}
inline ::pg_query::Node* Aggref::_internal_add_aggdistinct() {
  return aggdistinct_.Add();
}
inline ::pg_query::Node* Aggref::add_aggdistinct() {
  // @@protoc_insertion_point(field_add:pg_query.Aggref.aggdistinct)
  return _internal_add_aggdistinct();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Aggref::aggdistinct() const {
  // @@protoc_insertion_point(field_list:pg_query.Aggref.aggdistinct)
  return aggdistinct_;
}

// .pg_query.Node aggfilter = 12 [json_name = "aggfilter"];
inline bool Aggref::_internal_has_aggfilter() const {
  return this != internal_default_instance() && aggfilter_ != nullptr;
}
inline bool Aggref::has_aggfilter() const {
  return _internal_has_aggfilter();
}
inline void Aggref::clear_aggfilter() {
  if (GetArena() == nullptr && aggfilter_ != nullptr) {
    delete aggfilter_;
  }
  aggfilter_ = nullptr;
}
inline const ::pg_query::Node& Aggref::_internal_aggfilter() const {
  const ::pg_query::Node* p = aggfilter_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Aggref::aggfilter() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggfilter)
  return _internal_aggfilter();
}
inline void Aggref::unsafe_arena_set_allocated_aggfilter(
    ::pg_query::Node* aggfilter) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(aggfilter_);
  }
  aggfilter_ = aggfilter;
  if (aggfilter) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Aggref.aggfilter)
}
inline ::pg_query::Node* Aggref::release_aggfilter() {
  
  ::pg_query::Node* temp = aggfilter_;
  aggfilter_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* Aggref::unsafe_arena_release_aggfilter() {
  // @@protoc_insertion_point(field_release:pg_query.Aggref.aggfilter)
  
  ::pg_query::Node* temp = aggfilter_;
  aggfilter_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Aggref::_internal_mutable_aggfilter() {
  
  if (aggfilter_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    aggfilter_ = p;
  }
  return aggfilter_;
}
inline ::pg_query::Node* Aggref::mutable_aggfilter() {
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggfilter)
  return _internal_mutable_aggfilter();
}
inline void Aggref::set_allocated_aggfilter(::pg_query::Node* aggfilter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete aggfilter_;
  }
  if (aggfilter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(aggfilter);
    if (message_arena != submessage_arena) {
      aggfilter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, aggfilter, submessage_arena);
    }
    
  } else {
    
  }
  aggfilter_ = aggfilter;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Aggref.aggfilter)
}

// bool aggstar = 13 [json_name = "aggstar"];
inline void Aggref::clear_aggstar() {
  aggstar_ = false;
}
inline bool Aggref::_internal_aggstar() const {
  return aggstar_;
}
inline bool Aggref::aggstar() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggstar)
  return _internal_aggstar();
}
inline void Aggref::_internal_set_aggstar(bool value) {
  
  aggstar_ = value;
}
inline void Aggref::set_aggstar(bool value) {
  _internal_set_aggstar(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggstar)
}

// bool aggvariadic = 14 [json_name = "aggvariadic"];
inline void Aggref::clear_aggvariadic() {
  aggvariadic_ = false;
}
inline bool Aggref::_internal_aggvariadic() const {
  return aggvariadic_;
}
inline bool Aggref::aggvariadic() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggvariadic)
  return _internal_aggvariadic();
}
inline void Aggref::_internal_set_aggvariadic(bool value) {
  
  aggvariadic_ = value;
}
inline void Aggref::set_aggvariadic(bool value) {
  _internal_set_aggvariadic(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggvariadic)
}

// string aggkind = 15 [json_name = "aggkind"];
inline void Aggref::clear_aggkind() {
  aggkind_.ClearToEmpty();
}
inline const std::string& Aggref::aggkind() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggkind)
  return _internal_aggkind();
}
inline void Aggref::set_aggkind(const std::string& value) {
  _internal_set_aggkind(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggkind)
}
inline std::string* Aggref::mutable_aggkind() {
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggkind)
  return _internal_mutable_aggkind();
}
inline const std::string& Aggref::_internal_aggkind() const {
  return aggkind_.Get();
}
inline void Aggref::_internal_set_aggkind(const std::string& value) {
  
  aggkind_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Aggref::set_aggkind(std::string&& value) {
  
  aggkind_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.Aggref.aggkind)
}
inline void Aggref::set_aggkind(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  aggkind_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.Aggref.aggkind)
}
inline void Aggref::set_aggkind(const char* value,
    size_t size) {
  
  aggkind_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.Aggref.aggkind)
}
inline std::string* Aggref::_internal_mutable_aggkind() {
  
  return aggkind_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Aggref::release_aggkind() {
  // @@protoc_insertion_point(field_release:pg_query.Aggref.aggkind)
  return aggkind_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Aggref::set_allocated_aggkind(std::string* aggkind) {
  if (aggkind != nullptr) {
    
  } else {
    
  }
  aggkind_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), aggkind,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.Aggref.aggkind)
}

// uint32 agglevelsup = 16 [json_name = "agglevelsup"];
inline void Aggref::clear_agglevelsup() {
  agglevelsup_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Aggref::_internal_agglevelsup() const {
  return agglevelsup_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Aggref::agglevelsup() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.agglevelsup)
  return _internal_agglevelsup();
}
inline void Aggref::_internal_set_agglevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  agglevelsup_ = value;
}
inline void Aggref::set_agglevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_agglevelsup(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.agglevelsup)
}

// .pg_query.AggSplit aggsplit = 17 [json_name = "aggsplit"];
inline void Aggref::clear_aggsplit() {
  aggsplit_ = 0;
}
inline ::pg_query::AggSplit Aggref::_internal_aggsplit() const {
  return static_cast< ::pg_query::AggSplit >(aggsplit_);
}
inline ::pg_query::AggSplit Aggref::aggsplit() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggsplit)
  return _internal_aggsplit();
}
inline void Aggref::_internal_set_aggsplit(::pg_query::AggSplit value) {
  
  aggsplit_ = value;
}
inline void Aggref::set_aggsplit(::pg_query::AggSplit value) {
  _internal_set_aggsplit(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggsplit)
}

// int32 location = 18 [json_name = "location"];
inline void Aggref::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Aggref::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Aggref::location() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.location)
  return _internal_location();
}
inline void Aggref::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void Aggref::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.location)
}

// -------------------------------------------------------------------

// GroupingFunc

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool GroupingFunc::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool GroupingFunc::has_xpr() const {
  return _internal_has_xpr();
}
inline void GroupingFunc::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& GroupingFunc::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& GroupingFunc::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.xpr)
  return _internal_xpr();
}
inline void GroupingFunc::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.GroupingFunc.xpr)
}
inline ::pg_query::Node* GroupingFunc::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* GroupingFunc::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.GroupingFunc.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* GroupingFunc::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* GroupingFunc::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.GroupingFunc.xpr)
  return _internal_mutable_xpr();
}
inline void GroupingFunc::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.GroupingFunc.xpr)
}

// repeated .pg_query.Node args = 2 [json_name = "args"];
inline int GroupingFunc::_internal_args_size() const {
  return args_.size();
}
inline int GroupingFunc::args_size() const {
  return _internal_args_size();
}
inline void GroupingFunc::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* GroupingFunc::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.GroupingFunc.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
GroupingFunc::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GroupingFunc.args)
  return &args_;
}
inline const ::pg_query::Node& GroupingFunc::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& GroupingFunc::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.args)
  return _internal_args(index);
}
inline ::pg_query::Node* GroupingFunc::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* GroupingFunc::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.GroupingFunc.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
GroupingFunc::args() const {
  // @@protoc_insertion_point(field_list:pg_query.GroupingFunc.args)
  return args_;
}

// repeated .pg_query.Node refs = 3 [json_name = "refs"];
inline int GroupingFunc::_internal_refs_size() const {
  return refs_.size();
}
inline int GroupingFunc::refs_size() const {
  return _internal_refs_size();
}
inline void GroupingFunc::clear_refs() {
  refs_.Clear();
}
inline ::pg_query::Node* GroupingFunc::mutable_refs(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.GroupingFunc.refs)
  return refs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
GroupingFunc::mutable_refs() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GroupingFunc.refs)
  return &refs_;
}
inline const ::pg_query::Node& GroupingFunc::_internal_refs(int index) const {
  return refs_.Get(index);
}
inline const ::pg_query::Node& GroupingFunc::refs(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.refs)
  return _internal_refs(index);
}
inline ::pg_query::Node* GroupingFunc::_internal_add_refs() {
  return refs_.Add();
}
inline ::pg_query::Node* GroupingFunc::add_refs() {
  // @@protoc_insertion_point(field_add:pg_query.GroupingFunc.refs)
  return _internal_add_refs();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
GroupingFunc::refs() const {
  // @@protoc_insertion_point(field_list:pg_query.GroupingFunc.refs)
  return refs_;
}

// repeated .pg_query.Node cols = 4 [json_name = "cols"];
inline int GroupingFunc::_internal_cols_size() const {
  return cols_.size();
}
inline int GroupingFunc::cols_size() const {
  return _internal_cols_size();
}
inline void GroupingFunc::clear_cols() {
  cols_.Clear();
}
inline ::pg_query::Node* GroupingFunc::mutable_cols(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.GroupingFunc.cols)
  return cols_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
GroupingFunc::mutable_cols() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GroupingFunc.cols)
  return &cols_;
}
inline const ::pg_query::Node& GroupingFunc::_internal_cols(int index) const {
  return cols_.Get(index);
}
inline const ::pg_query::Node& GroupingFunc::cols(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.cols)
  return _internal_cols(index);
}
inline ::pg_query::Node* GroupingFunc::_internal_add_cols() {
  return cols_.Add();
}
inline ::pg_query::Node* GroupingFunc::add_cols() {
  // @@protoc_insertion_point(field_add:pg_query.GroupingFunc.cols)
  return _internal_add_cols();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
GroupingFunc::cols() const {
  // @@protoc_insertion_point(field_list:pg_query.GroupingFunc.cols)
  return cols_;
}

// uint32 agglevelsup = 5 [json_name = "agglevelsup"];
inline void GroupingFunc::clear_agglevelsup() {
  agglevelsup_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 GroupingFunc::_internal_agglevelsup() const {
  return agglevelsup_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 GroupingFunc::agglevelsup() const {
  // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.agglevelsup)
  return _internal_agglevelsup();
}
inline void GroupingFunc::_internal_set_agglevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  agglevelsup_ = value;
}
inline void GroupingFunc::set_agglevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_agglevelsup(value);
  // @@protoc_insertion_point(field_set:pg_query.GroupingFunc.agglevelsup)
}

// int32 location = 6 [json_name = "location"];
inline void GroupingFunc::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GroupingFunc::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GroupingFunc::location() const {
  // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.location)
  return _internal_location();
}
inline void GroupingFunc::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void GroupingFunc::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.GroupingFunc.location)
}

// -------------------------------------------------------------------

// WindowFunc

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool WindowFunc::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool WindowFunc::has_xpr() const {
  return _internal_has_xpr();
}
inline void WindowFunc::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& WindowFunc::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& WindowFunc::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.xpr)
  return _internal_xpr();
}
inline void WindowFunc::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowFunc.xpr)
}
inline ::pg_query::Node* WindowFunc::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* WindowFunc::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.WindowFunc.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WindowFunc::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* WindowFunc::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowFunc.xpr)
  return _internal_mutable_xpr();
}
inline void WindowFunc::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowFunc.xpr)
}

// uint32 winfnoid = 2 [json_name = "winfnoid"];
inline void WindowFunc::clear_winfnoid() {
  winfnoid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowFunc::_internal_winfnoid() const {
  return winfnoid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowFunc::winfnoid() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.winfnoid)
  return _internal_winfnoid();
}
inline void WindowFunc::_internal_set_winfnoid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  winfnoid_ = value;
}
inline void WindowFunc::set_winfnoid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_winfnoid(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.winfnoid)
}

// uint32 wintype = 3 [json_name = "wintype"];
inline void WindowFunc::clear_wintype() {
  wintype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowFunc::_internal_wintype() const {
  return wintype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowFunc::wintype() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.wintype)
  return _internal_wintype();
}
inline void WindowFunc::_internal_set_wintype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  wintype_ = value;
}
inline void WindowFunc::set_wintype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_wintype(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.wintype)
}

// uint32 wincollid = 4 [json_name = "wincollid"];
inline void WindowFunc::clear_wincollid() {
  wincollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowFunc::_internal_wincollid() const {
  return wincollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowFunc::wincollid() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.wincollid)
  return _internal_wincollid();
}
inline void WindowFunc::_internal_set_wincollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  wincollid_ = value;
}
inline void WindowFunc::set_wincollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_wincollid(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.wincollid)
}

// uint32 inputcollid = 5 [json_name = "inputcollid"];
inline void WindowFunc::clear_inputcollid() {
  inputcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowFunc::_internal_inputcollid() const {
  return inputcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowFunc::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.inputcollid)
  return _internal_inputcollid();
}
inline void WindowFunc::_internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  inputcollid_ = value;
}
inline void WindowFunc::set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.inputcollid)
}

// repeated .pg_query.Node args = 6 [json_name = "args"];
inline int WindowFunc::_internal_args_size() const {
  return args_.size();
}
inline int WindowFunc::args_size() const {
  return _internal_args_size();
}
inline void WindowFunc::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* WindowFunc::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowFunc.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
WindowFunc::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.WindowFunc.args)
  return &args_;
}
inline const ::pg_query::Node& WindowFunc::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& WindowFunc::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.args)
  return _internal_args(index);
}
inline ::pg_query::Node* WindowFunc::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* WindowFunc::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.WindowFunc.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
WindowFunc::args() const {
  // @@protoc_insertion_point(field_list:pg_query.WindowFunc.args)
  return args_;
}

// .pg_query.Node aggfilter = 7 [json_name = "aggfilter"];
inline bool WindowFunc::_internal_has_aggfilter() const {
  return this != internal_default_instance() && aggfilter_ != nullptr;
}
inline bool WindowFunc::has_aggfilter() const {
  return _internal_has_aggfilter();
}
inline void WindowFunc::clear_aggfilter() {
  if (GetArena() == nullptr && aggfilter_ != nullptr) {
    delete aggfilter_;
  }
  aggfilter_ = nullptr;
}
inline const ::pg_query::Node& WindowFunc::_internal_aggfilter() const {
  const ::pg_query::Node* p = aggfilter_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& WindowFunc::aggfilter() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.aggfilter)
  return _internal_aggfilter();
}
inline void WindowFunc::unsafe_arena_set_allocated_aggfilter(
    ::pg_query::Node* aggfilter) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(aggfilter_);
  }
  aggfilter_ = aggfilter;
  if (aggfilter) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowFunc.aggfilter)
}
inline ::pg_query::Node* WindowFunc::release_aggfilter() {
  
  ::pg_query::Node* temp = aggfilter_;
  aggfilter_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* WindowFunc::unsafe_arena_release_aggfilter() {
  // @@protoc_insertion_point(field_release:pg_query.WindowFunc.aggfilter)
  
  ::pg_query::Node* temp = aggfilter_;
  aggfilter_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WindowFunc::_internal_mutable_aggfilter() {
  
  if (aggfilter_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    aggfilter_ = p;
  }
  return aggfilter_;
}
inline ::pg_query::Node* WindowFunc::mutable_aggfilter() {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowFunc.aggfilter)
  return _internal_mutable_aggfilter();
}
inline void WindowFunc::set_allocated_aggfilter(::pg_query::Node* aggfilter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete aggfilter_;
  }
  if (aggfilter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(aggfilter);
    if (message_arena != submessage_arena) {
      aggfilter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, aggfilter, submessage_arena);
    }
    
  } else {
    
  }
  aggfilter_ = aggfilter;
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowFunc.aggfilter)
}

// uint32 winref = 8 [json_name = "winref"];
inline void WindowFunc::clear_winref() {
  winref_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowFunc::_internal_winref() const {
  return winref_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowFunc::winref() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.winref)
  return _internal_winref();
}
inline void WindowFunc::_internal_set_winref(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  winref_ = value;
}
inline void WindowFunc::set_winref(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_winref(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.winref)
}

// bool winstar = 9 [json_name = "winstar"];
inline void WindowFunc::clear_winstar() {
  winstar_ = false;
}
inline bool WindowFunc::_internal_winstar() const {
  return winstar_;
}
inline bool WindowFunc::winstar() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.winstar)
  return _internal_winstar();
}
inline void WindowFunc::_internal_set_winstar(bool value) {
  
  winstar_ = value;
}
inline void WindowFunc::set_winstar(bool value) {
  _internal_set_winstar(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.winstar)
}

// bool winagg = 10 [json_name = "winagg"];
inline void WindowFunc::clear_winagg() {
  winagg_ = false;
}
inline bool WindowFunc::_internal_winagg() const {
  return winagg_;
}
inline bool WindowFunc::winagg() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.winagg)
  return _internal_winagg();
}
inline void WindowFunc::_internal_set_winagg(bool value) {
  
  winagg_ = value;
}
inline void WindowFunc::set_winagg(bool value) {
  _internal_set_winagg(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.winagg)
}

// int32 location = 11 [json_name = "location"];
inline void WindowFunc::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 WindowFunc::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 WindowFunc::location() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.location)
  return _internal_location();
}
inline void WindowFunc::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void WindowFunc::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.location)
}

// -------------------------------------------------------------------

// SubscriptingRef

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool SubscriptingRef::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool SubscriptingRef::has_xpr() const {
  return _internal_has_xpr();
}
inline void SubscriptingRef::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& SubscriptingRef::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubscriptingRef::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.xpr)
  return _internal_xpr();
}
inline void SubscriptingRef::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubscriptingRef.xpr)
}
inline ::pg_query::Node* SubscriptingRef::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SubscriptingRef::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.SubscriptingRef.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubscriptingRef::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* SubscriptingRef::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.SubscriptingRef.xpr)
  return _internal_mutable_xpr();
}
inline void SubscriptingRef::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SubscriptingRef.xpr)
}

// uint32 refcontainertype = 2 [json_name = "refcontainertype"];
inline void SubscriptingRef::clear_refcontainertype() {
  refcontainertype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SubscriptingRef::_internal_refcontainertype() const {
  return refcontainertype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SubscriptingRef::refcontainertype() const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refcontainertype)
  return _internal_refcontainertype();
}
inline void SubscriptingRef::_internal_set_refcontainertype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  refcontainertype_ = value;
}
inline void SubscriptingRef::set_refcontainertype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_refcontainertype(value);
  // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.refcontainertype)
}

// uint32 refelemtype = 3 [json_name = "refelemtype"];
inline void SubscriptingRef::clear_refelemtype() {
  refelemtype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SubscriptingRef::_internal_refelemtype() const {
  return refelemtype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SubscriptingRef::refelemtype() const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refelemtype)
  return _internal_refelemtype();
}
inline void SubscriptingRef::_internal_set_refelemtype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  refelemtype_ = value;
}
inline void SubscriptingRef::set_refelemtype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_refelemtype(value);
  // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.refelemtype)
}

// int32 reftypmod = 4 [json_name = "reftypmod"];
inline void SubscriptingRef::clear_reftypmod() {
  reftypmod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SubscriptingRef::_internal_reftypmod() const {
  return reftypmod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SubscriptingRef::reftypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.reftypmod)
  return _internal_reftypmod();
}
inline void SubscriptingRef::_internal_set_reftypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  reftypmod_ = value;
}
inline void SubscriptingRef::set_reftypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_reftypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.reftypmod)
}

// uint32 refcollid = 5 [json_name = "refcollid"];
inline void SubscriptingRef::clear_refcollid() {
  refcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SubscriptingRef::_internal_refcollid() const {
  return refcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SubscriptingRef::refcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refcollid)
  return _internal_refcollid();
}
inline void SubscriptingRef::_internal_set_refcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  refcollid_ = value;
}
inline void SubscriptingRef::set_refcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_refcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.refcollid)
}

// repeated .pg_query.Node refupperindexpr = 6 [json_name = "refupperindexpr"];
inline int SubscriptingRef::_internal_refupperindexpr_size() const {
  return refupperindexpr_.size();
}
inline int SubscriptingRef::refupperindexpr_size() const {
  return _internal_refupperindexpr_size();
}
inline void SubscriptingRef::clear_refupperindexpr() {
  refupperindexpr_.Clear();
}
inline ::pg_query::Node* SubscriptingRef::mutable_refupperindexpr(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SubscriptingRef.refupperindexpr)
  return refupperindexpr_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SubscriptingRef::mutable_refupperindexpr() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubscriptingRef.refupperindexpr)
  return &refupperindexpr_;
}
inline const ::pg_query::Node& SubscriptingRef::_internal_refupperindexpr(int index) const {
  return refupperindexpr_.Get(index);
}
inline const ::pg_query::Node& SubscriptingRef::refupperindexpr(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refupperindexpr)
  return _internal_refupperindexpr(index);
}
inline ::pg_query::Node* SubscriptingRef::_internal_add_refupperindexpr() {
  return refupperindexpr_.Add();
}
inline ::pg_query::Node* SubscriptingRef::add_refupperindexpr() {
  // @@protoc_insertion_point(field_add:pg_query.SubscriptingRef.refupperindexpr)
  return _internal_add_refupperindexpr();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SubscriptingRef::refupperindexpr() const {
  // @@protoc_insertion_point(field_list:pg_query.SubscriptingRef.refupperindexpr)
  return refupperindexpr_;
}

// repeated .pg_query.Node reflowerindexpr = 7 [json_name = "reflowerindexpr"];
inline int SubscriptingRef::_internal_reflowerindexpr_size() const {
  return reflowerindexpr_.size();
}
inline int SubscriptingRef::reflowerindexpr_size() const {
  return _internal_reflowerindexpr_size();
}
inline void SubscriptingRef::clear_reflowerindexpr() {
  reflowerindexpr_.Clear();
}
inline ::pg_query::Node* SubscriptingRef::mutable_reflowerindexpr(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SubscriptingRef.reflowerindexpr)
  return reflowerindexpr_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SubscriptingRef::mutable_reflowerindexpr() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubscriptingRef.reflowerindexpr)
  return &reflowerindexpr_;
}
inline const ::pg_query::Node& SubscriptingRef::_internal_reflowerindexpr(int index) const {
  return reflowerindexpr_.Get(index);
}
inline const ::pg_query::Node& SubscriptingRef::reflowerindexpr(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.reflowerindexpr)
  return _internal_reflowerindexpr(index);
}
inline ::pg_query::Node* SubscriptingRef::_internal_add_reflowerindexpr() {
  return reflowerindexpr_.Add();
}
inline ::pg_query::Node* SubscriptingRef::add_reflowerindexpr() {
  // @@protoc_insertion_point(field_add:pg_query.SubscriptingRef.reflowerindexpr)
  return _internal_add_reflowerindexpr();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SubscriptingRef::reflowerindexpr() const {
  // @@protoc_insertion_point(field_list:pg_query.SubscriptingRef.reflowerindexpr)
  return reflowerindexpr_;
}

// .pg_query.Node refexpr = 8 [json_name = "refexpr"];
inline bool SubscriptingRef::_internal_has_refexpr() const {
  return this != internal_default_instance() && refexpr_ != nullptr;
}
inline bool SubscriptingRef::has_refexpr() const {
  return _internal_has_refexpr();
}
inline void SubscriptingRef::clear_refexpr() {
  if (GetArena() == nullptr && refexpr_ != nullptr) {
    delete refexpr_;
  }
  refexpr_ = nullptr;
}
inline const ::pg_query::Node& SubscriptingRef::_internal_refexpr() const {
  const ::pg_query::Node* p = refexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubscriptingRef::refexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refexpr)
  return _internal_refexpr();
}
inline void SubscriptingRef::unsafe_arena_set_allocated_refexpr(
    ::pg_query::Node* refexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(refexpr_);
  }
  refexpr_ = refexpr;
  if (refexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubscriptingRef.refexpr)
}
inline ::pg_query::Node* SubscriptingRef::release_refexpr() {
  
  ::pg_query::Node* temp = refexpr_;
  refexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SubscriptingRef::unsafe_arena_release_refexpr() {
  // @@protoc_insertion_point(field_release:pg_query.SubscriptingRef.refexpr)
  
  ::pg_query::Node* temp = refexpr_;
  refexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubscriptingRef::_internal_mutable_refexpr() {
  
  if (refexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    refexpr_ = p;
  }
  return refexpr_;
}
inline ::pg_query::Node* SubscriptingRef::mutable_refexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.SubscriptingRef.refexpr)
  return _internal_mutable_refexpr();
}
inline void SubscriptingRef::set_allocated_refexpr(::pg_query::Node* refexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete refexpr_;
  }
  if (refexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(refexpr);
    if (message_arena != submessage_arena) {
      refexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, refexpr, submessage_arena);
    }
    
  } else {
    
  }
  refexpr_ = refexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SubscriptingRef.refexpr)
}

// .pg_query.Node refassgnexpr = 9 [json_name = "refassgnexpr"];
inline bool SubscriptingRef::_internal_has_refassgnexpr() const {
  return this != internal_default_instance() && refassgnexpr_ != nullptr;
}
inline bool SubscriptingRef::has_refassgnexpr() const {
  return _internal_has_refassgnexpr();
}
inline void SubscriptingRef::clear_refassgnexpr() {
  if (GetArena() == nullptr && refassgnexpr_ != nullptr) {
    delete refassgnexpr_;
  }
  refassgnexpr_ = nullptr;
}
inline const ::pg_query::Node& SubscriptingRef::_internal_refassgnexpr() const {
  const ::pg_query::Node* p = refassgnexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubscriptingRef::refassgnexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refassgnexpr)
  return _internal_refassgnexpr();
}
inline void SubscriptingRef::unsafe_arena_set_allocated_refassgnexpr(
    ::pg_query::Node* refassgnexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(refassgnexpr_);
  }
  refassgnexpr_ = refassgnexpr;
  if (refassgnexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubscriptingRef.refassgnexpr)
}
inline ::pg_query::Node* SubscriptingRef::release_refassgnexpr() {
  
  ::pg_query::Node* temp = refassgnexpr_;
  refassgnexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SubscriptingRef::unsafe_arena_release_refassgnexpr() {
  // @@protoc_insertion_point(field_release:pg_query.SubscriptingRef.refassgnexpr)
  
  ::pg_query::Node* temp = refassgnexpr_;
  refassgnexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubscriptingRef::_internal_mutable_refassgnexpr() {
  
  if (refassgnexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    refassgnexpr_ = p;
  }
  return refassgnexpr_;
}
inline ::pg_query::Node* SubscriptingRef::mutable_refassgnexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.SubscriptingRef.refassgnexpr)
  return _internal_mutable_refassgnexpr();
}
inline void SubscriptingRef::set_allocated_refassgnexpr(::pg_query::Node* refassgnexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete refassgnexpr_;
  }
  if (refassgnexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(refassgnexpr);
    if (message_arena != submessage_arena) {
      refassgnexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, refassgnexpr, submessage_arena);
    }
    
  } else {
    
  }
  refassgnexpr_ = refassgnexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SubscriptingRef.refassgnexpr)
}

// -------------------------------------------------------------------

// FuncExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool FuncExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool FuncExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void FuncExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& FuncExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FuncExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.xpr)
  return _internal_xpr();
}
inline void FuncExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FuncExpr.xpr)
}
inline ::pg_query::Node* FuncExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* FuncExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.FuncExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FuncExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* FuncExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.FuncExpr.xpr)
  return _internal_mutable_xpr();
}
inline void FuncExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.FuncExpr.xpr)
}

// uint32 funcid = 2 [json_name = "funcid"];
inline void FuncExpr::clear_funcid() {
  funcid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FuncExpr::_internal_funcid() const {
  return funcid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FuncExpr::funcid() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcid)
  return _internal_funcid();
}
inline void FuncExpr::_internal_set_funcid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  funcid_ = value;
}
inline void FuncExpr::set_funcid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_funcid(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcid)
}

// uint32 funcresulttype = 3 [json_name = "funcresulttype"];
inline void FuncExpr::clear_funcresulttype() {
  funcresulttype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FuncExpr::_internal_funcresulttype() const {
  return funcresulttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FuncExpr::funcresulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcresulttype)
  return _internal_funcresulttype();
}
inline void FuncExpr::_internal_set_funcresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  funcresulttype_ = value;
}
inline void FuncExpr::set_funcresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_funcresulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcresulttype)
}

// bool funcretset = 4 [json_name = "funcretset"];
inline void FuncExpr::clear_funcretset() {
  funcretset_ = false;
}
inline bool FuncExpr::_internal_funcretset() const {
  return funcretset_;
}
inline bool FuncExpr::funcretset() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcretset)
  return _internal_funcretset();
}
inline void FuncExpr::_internal_set_funcretset(bool value) {
  
  funcretset_ = value;
}
inline void FuncExpr::set_funcretset(bool value) {
  _internal_set_funcretset(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcretset)
}

// bool funcvariadic = 5 [json_name = "funcvariadic"];
inline void FuncExpr::clear_funcvariadic() {
  funcvariadic_ = false;
}
inline bool FuncExpr::_internal_funcvariadic() const {
  return funcvariadic_;
}
inline bool FuncExpr::funcvariadic() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcvariadic)
  return _internal_funcvariadic();
}
inline void FuncExpr::_internal_set_funcvariadic(bool value) {
  
  funcvariadic_ = value;
}
inline void FuncExpr::set_funcvariadic(bool value) {
  _internal_set_funcvariadic(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcvariadic)
}

// .pg_query.CoercionForm funcformat = 6 [json_name = "funcformat"];
inline void FuncExpr::clear_funcformat() {
  funcformat_ = 0;
}
inline ::pg_query::CoercionForm FuncExpr::_internal_funcformat() const {
  return static_cast< ::pg_query::CoercionForm >(funcformat_);
}
inline ::pg_query::CoercionForm FuncExpr::funcformat() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcformat)
  return _internal_funcformat();
}
inline void FuncExpr::_internal_set_funcformat(::pg_query::CoercionForm value) {
  
  funcformat_ = value;
}
inline void FuncExpr::set_funcformat(::pg_query::CoercionForm value) {
  _internal_set_funcformat(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcformat)
}

// uint32 funccollid = 7 [json_name = "funccollid"];
inline void FuncExpr::clear_funccollid() {
  funccollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FuncExpr::_internal_funccollid() const {
  return funccollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FuncExpr::funccollid() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funccollid)
  return _internal_funccollid();
}
inline void FuncExpr::_internal_set_funccollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  funccollid_ = value;
}
inline void FuncExpr::set_funccollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_funccollid(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funccollid)
}

// uint32 inputcollid = 8 [json_name = "inputcollid"];
inline void FuncExpr::clear_inputcollid() {
  inputcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FuncExpr::_internal_inputcollid() const {
  return inputcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FuncExpr::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.inputcollid)
  return _internal_inputcollid();
}
inline void FuncExpr::_internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  inputcollid_ = value;
}
inline void FuncExpr::set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.inputcollid)
}

// repeated .pg_query.Node args = 9 [json_name = "args"];
inline int FuncExpr::_internal_args_size() const {
  return args_.size();
}
inline int FuncExpr::args_size() const {
  return _internal_args_size();
}
inline void FuncExpr::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* FuncExpr::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.FuncExpr.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
FuncExpr::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FuncExpr.args)
  return &args_;
}
inline const ::pg_query::Node& FuncExpr::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& FuncExpr::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.args)
  return _internal_args(index);
}
inline ::pg_query::Node* FuncExpr::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* FuncExpr::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.FuncExpr.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
FuncExpr::args() const {
  // @@protoc_insertion_point(field_list:pg_query.FuncExpr.args)
  return args_;
}

// int32 location = 10 [json_name = "location"];
inline void FuncExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FuncExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FuncExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.location)
  return _internal_location();
}
inline void FuncExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void FuncExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.location)
}

// -------------------------------------------------------------------

// NamedArgExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool NamedArgExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool NamedArgExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void NamedArgExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& NamedArgExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& NamedArgExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.xpr)
  return _internal_xpr();
}
inline void NamedArgExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NamedArgExpr.xpr)
}
inline ::pg_query::Node* NamedArgExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* NamedArgExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.NamedArgExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* NamedArgExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* NamedArgExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.NamedArgExpr.xpr)
  return _internal_mutable_xpr();
}
inline void NamedArgExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.NamedArgExpr.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool NamedArgExpr::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool NamedArgExpr::has_arg() const {
  return _internal_has_arg();
}
inline void NamedArgExpr::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& NamedArgExpr::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& NamedArgExpr::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.arg)
  return _internal_arg();
}
inline void NamedArgExpr::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NamedArgExpr.arg)
}
inline ::pg_query::Node* NamedArgExpr::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* NamedArgExpr::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.NamedArgExpr.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* NamedArgExpr::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* NamedArgExpr::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.NamedArgExpr.arg)
  return _internal_mutable_arg();
}
inline void NamedArgExpr::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.NamedArgExpr.arg)
}

// string name = 3 [json_name = "name"];
inline void NamedArgExpr::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& NamedArgExpr::name() const {
  // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.name)
  return _internal_name();
}
inline void NamedArgExpr::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.NamedArgExpr.name)
}
inline std::string* NamedArgExpr::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.NamedArgExpr.name)
  return _internal_mutable_name();
}
inline const std::string& NamedArgExpr::_internal_name() const {
  return name_.Get();
}
inline void NamedArgExpr::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void NamedArgExpr::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.NamedArgExpr.name)
}
inline void NamedArgExpr::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.NamedArgExpr.name)
}
inline void NamedArgExpr::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.NamedArgExpr.name)
}
inline std::string* NamedArgExpr::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* NamedArgExpr::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.NamedArgExpr.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void NamedArgExpr::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.NamedArgExpr.name)
}

// int32 argnumber = 4 [json_name = "argnumber"];
inline void NamedArgExpr::clear_argnumber() {
  argnumber_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 NamedArgExpr::_internal_argnumber() const {
  return argnumber_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 NamedArgExpr::argnumber() const {
  // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.argnumber)
  return _internal_argnumber();
}
inline void NamedArgExpr::_internal_set_argnumber(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  argnumber_ = value;
}
inline void NamedArgExpr::set_argnumber(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_argnumber(value);
  // @@protoc_insertion_point(field_set:pg_query.NamedArgExpr.argnumber)
}

// int32 location = 5 [json_name = "location"];
inline void NamedArgExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 NamedArgExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 NamedArgExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.location)
  return _internal_location();
}
inline void NamedArgExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void NamedArgExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.NamedArgExpr.location)
}

// -------------------------------------------------------------------

// OpExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool OpExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool OpExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void OpExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& OpExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& OpExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.xpr)
  return _internal_xpr();
}
inline void OpExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OpExpr.xpr)
}
inline ::pg_query::Node* OpExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* OpExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.OpExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* OpExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* OpExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.OpExpr.xpr)
  return _internal_mutable_xpr();
}
inline void OpExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.OpExpr.xpr)
}

// uint32 opno = 2 [json_name = "opno"];
inline void OpExpr::clear_opno() {
  opno_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 OpExpr::_internal_opno() const {
  return opno_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 OpExpr::opno() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.opno)
  return _internal_opno();
}
inline void OpExpr::_internal_set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opno_ = value;
}
inline void OpExpr::set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opno(value);
  // @@protoc_insertion_point(field_set:pg_query.OpExpr.opno)
}

// uint32 opfuncid = 3 [json_name = "opfuncid"];
inline void OpExpr::clear_opfuncid() {
  opfuncid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 OpExpr::_internal_opfuncid() const {
  return opfuncid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 OpExpr::opfuncid() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.opfuncid)
  return _internal_opfuncid();
}
inline void OpExpr::_internal_set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opfuncid_ = value;
}
inline void OpExpr::set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opfuncid(value);
  // @@protoc_insertion_point(field_set:pg_query.OpExpr.opfuncid)
}

// uint32 opresulttype = 4 [json_name = "opresulttype"];
inline void OpExpr::clear_opresulttype() {
  opresulttype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 OpExpr::_internal_opresulttype() const {
  return opresulttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 OpExpr::opresulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.opresulttype)
  return _internal_opresulttype();
}
inline void OpExpr::_internal_set_opresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opresulttype_ = value;
}
inline void OpExpr::set_opresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opresulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.OpExpr.opresulttype)
}

// bool opretset = 5 [json_name = "opretset"];
inline void OpExpr::clear_opretset() {
  opretset_ = false;
}
inline bool OpExpr::_internal_opretset() const {
  return opretset_;
}
inline bool OpExpr::opretset() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.opretset)
  return _internal_opretset();
}
inline void OpExpr::_internal_set_opretset(bool value) {
  
  opretset_ = value;
}
inline void OpExpr::set_opretset(bool value) {
  _internal_set_opretset(value);
  // @@protoc_insertion_point(field_set:pg_query.OpExpr.opretset)
}

// uint32 opcollid = 6 [json_name = "opcollid"];
inline void OpExpr::clear_opcollid() {
  opcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 OpExpr::_internal_opcollid() const {
  return opcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 OpExpr::opcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.opcollid)
  return _internal_opcollid();
}
inline void OpExpr::_internal_set_opcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opcollid_ = value;
}
inline void OpExpr::set_opcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.OpExpr.opcollid)
}

// uint32 inputcollid = 7 [json_name = "inputcollid"];
inline void OpExpr::clear_inputcollid() {
  inputcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 OpExpr::_internal_inputcollid() const {
  return inputcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 OpExpr::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.inputcollid)
  return _internal_inputcollid();
}
inline void OpExpr::_internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  inputcollid_ = value;
}
inline void OpExpr::set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.OpExpr.inputcollid)
}

// repeated .pg_query.Node args = 8 [json_name = "args"];
inline int OpExpr::_internal_args_size() const {
  return args_.size();
}
inline int OpExpr::args_size() const {
  return _internal_args_size();
}
inline void OpExpr::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* OpExpr::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.OpExpr.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
OpExpr::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.OpExpr.args)
  return &args_;
}
inline const ::pg_query::Node& OpExpr::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& OpExpr::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.args)
  return _internal_args(index);
}
inline ::pg_query::Node* OpExpr::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* OpExpr::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.OpExpr.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
OpExpr::args() const {
  // @@protoc_insertion_point(field_list:pg_query.OpExpr.args)
  return args_;
}

// int32 location = 9 [json_name = "location"];
inline void OpExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 OpExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 OpExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.location)
  return _internal_location();
}
inline void OpExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void OpExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.OpExpr.location)
}

// -------------------------------------------------------------------

// DistinctExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool DistinctExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool DistinctExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void DistinctExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& DistinctExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& DistinctExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.xpr)
  return _internal_xpr();
}
inline void DistinctExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DistinctExpr.xpr)
}
inline ::pg_query::Node* DistinctExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* DistinctExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.DistinctExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* DistinctExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* DistinctExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.DistinctExpr.xpr)
  return _internal_mutable_xpr();
}
inline void DistinctExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.DistinctExpr.xpr)
}

// uint32 opno = 2 [json_name = "opno"];
inline void DistinctExpr::clear_opno() {
  opno_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DistinctExpr::_internal_opno() const {
  return opno_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DistinctExpr::opno() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opno)
  return _internal_opno();
}
inline void DistinctExpr::_internal_set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opno_ = value;
}
inline void DistinctExpr::set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opno(value);
  // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opno)
}

// uint32 opfuncid = 3 [json_name = "opfuncid"];
inline void DistinctExpr::clear_opfuncid() {
  opfuncid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DistinctExpr::_internal_opfuncid() const {
  return opfuncid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DistinctExpr::opfuncid() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opfuncid)
  return _internal_opfuncid();
}
inline void DistinctExpr::_internal_set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opfuncid_ = value;
}
inline void DistinctExpr::set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opfuncid(value);
  // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opfuncid)
}

// uint32 opresulttype = 4 [json_name = "opresulttype"];
inline void DistinctExpr::clear_opresulttype() {
  opresulttype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DistinctExpr::_internal_opresulttype() const {
  return opresulttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DistinctExpr::opresulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opresulttype)
  return _internal_opresulttype();
}
inline void DistinctExpr::_internal_set_opresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opresulttype_ = value;
}
inline void DistinctExpr::set_opresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opresulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opresulttype)
}

// bool opretset = 5 [json_name = "opretset"];
inline void DistinctExpr::clear_opretset() {
  opretset_ = false;
}
inline bool DistinctExpr::_internal_opretset() const {
  return opretset_;
}
inline bool DistinctExpr::opretset() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opretset)
  return _internal_opretset();
}
inline void DistinctExpr::_internal_set_opretset(bool value) {
  
  opretset_ = value;
}
inline void DistinctExpr::set_opretset(bool value) {
  _internal_set_opretset(value);
  // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opretset)
}

// uint32 opcollid = 6 [json_name = "opcollid"];
inline void DistinctExpr::clear_opcollid() {
  opcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DistinctExpr::_internal_opcollid() const {
  return opcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DistinctExpr::opcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opcollid)
  return _internal_opcollid();
}
inline void DistinctExpr::_internal_set_opcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opcollid_ = value;
}
inline void DistinctExpr::set_opcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opcollid)
}

// uint32 inputcollid = 7 [json_name = "inputcollid"];
inline void DistinctExpr::clear_inputcollid() {
  inputcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DistinctExpr::_internal_inputcollid() const {
  return inputcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DistinctExpr::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.inputcollid)
  return _internal_inputcollid();
}
inline void DistinctExpr::_internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  inputcollid_ = value;
}
inline void DistinctExpr::set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.inputcollid)
}

// repeated .pg_query.Node args = 8 [json_name = "args"];
inline int DistinctExpr::_internal_args_size() const {
  return args_.size();
}
inline int DistinctExpr::args_size() const {
  return _internal_args_size();
}
inline void DistinctExpr::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* DistinctExpr::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.DistinctExpr.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
DistinctExpr::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DistinctExpr.args)
  return &args_;
}
inline const ::pg_query::Node& DistinctExpr::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& DistinctExpr::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.args)
  return _internal_args(index);
}
inline ::pg_query::Node* DistinctExpr::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* DistinctExpr::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.DistinctExpr.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
DistinctExpr::args() const {
  // @@protoc_insertion_point(field_list:pg_query.DistinctExpr.args)
  return args_;
}

// int32 location = 9 [json_name = "location"];
inline void DistinctExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DistinctExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DistinctExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.location)
  return _internal_location();
}
inline void DistinctExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void DistinctExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.location)
}

// -------------------------------------------------------------------

// NullIfExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool NullIfExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool NullIfExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void NullIfExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& NullIfExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& NullIfExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.xpr)
  return _internal_xpr();
}
inline void NullIfExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NullIfExpr.xpr)
}
inline ::pg_query::Node* NullIfExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* NullIfExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.NullIfExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* NullIfExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* NullIfExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.NullIfExpr.xpr)
  return _internal_mutable_xpr();
}
inline void NullIfExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.NullIfExpr.xpr)
}

// uint32 opno = 2 [json_name = "opno"];
inline void NullIfExpr::clear_opno() {
  opno_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NullIfExpr::_internal_opno() const {
  return opno_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NullIfExpr::opno() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opno)
  return _internal_opno();
}
inline void NullIfExpr::_internal_set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opno_ = value;
}
inline void NullIfExpr::set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opno(value);
  // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opno)
}

// uint32 opfuncid = 3 [json_name = "opfuncid"];
inline void NullIfExpr::clear_opfuncid() {
  opfuncid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NullIfExpr::_internal_opfuncid() const {
  return opfuncid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NullIfExpr::opfuncid() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opfuncid)
  return _internal_opfuncid();
}
inline void NullIfExpr::_internal_set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opfuncid_ = value;
}
inline void NullIfExpr::set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opfuncid(value);
  // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opfuncid)
}

// uint32 opresulttype = 4 [json_name = "opresulttype"];
inline void NullIfExpr::clear_opresulttype() {
  opresulttype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NullIfExpr::_internal_opresulttype() const {
  return opresulttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NullIfExpr::opresulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opresulttype)
  return _internal_opresulttype();
}
inline void NullIfExpr::_internal_set_opresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opresulttype_ = value;
}
inline void NullIfExpr::set_opresulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opresulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opresulttype)
}

// bool opretset = 5 [json_name = "opretset"];
inline void NullIfExpr::clear_opretset() {
  opretset_ = false;
}
inline bool NullIfExpr::_internal_opretset() const {
  return opretset_;
}
inline bool NullIfExpr::opretset() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opretset)
  return _internal_opretset();
}
inline void NullIfExpr::_internal_set_opretset(bool value) {
  
  opretset_ = value;
}
inline void NullIfExpr::set_opretset(bool value) {
  _internal_set_opretset(value);
  // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opretset)
}

// uint32 opcollid = 6 [json_name = "opcollid"];
inline void NullIfExpr::clear_opcollid() {
  opcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NullIfExpr::_internal_opcollid() const {
  return opcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NullIfExpr::opcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opcollid)
  return _internal_opcollid();
}
inline void NullIfExpr::_internal_set_opcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opcollid_ = value;
}
inline void NullIfExpr::set_opcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opcollid)
}

// uint32 inputcollid = 7 [json_name = "inputcollid"];
inline void NullIfExpr::clear_inputcollid() {
  inputcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NullIfExpr::_internal_inputcollid() const {
  return inputcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NullIfExpr::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.inputcollid)
  return _internal_inputcollid();
}
inline void NullIfExpr::_internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  inputcollid_ = value;
}
inline void NullIfExpr::set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.inputcollid)
}

// repeated .pg_query.Node args = 8 [json_name = "args"];
inline int NullIfExpr::_internal_args_size() const {
  return args_.size();
}
inline int NullIfExpr::args_size() const {
  return _internal_args_size();
}
inline void NullIfExpr::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* NullIfExpr::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.NullIfExpr.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
NullIfExpr::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.NullIfExpr.args)
  return &args_;
}
inline const ::pg_query::Node& NullIfExpr::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& NullIfExpr::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.args)
  return _internal_args(index);
}
inline ::pg_query::Node* NullIfExpr::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* NullIfExpr::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.NullIfExpr.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
NullIfExpr::args() const {
  // @@protoc_insertion_point(field_list:pg_query.NullIfExpr.args)
  return args_;
}

// int32 location = 9 [json_name = "location"];
inline void NullIfExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 NullIfExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 NullIfExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.location)
  return _internal_location();
}
inline void NullIfExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void NullIfExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.location)
}

// -------------------------------------------------------------------

// ScalarArrayOpExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool ScalarArrayOpExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool ScalarArrayOpExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void ScalarArrayOpExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& ScalarArrayOpExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ScalarArrayOpExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.xpr)
  return _internal_xpr();
}
inline void ScalarArrayOpExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ScalarArrayOpExpr.xpr)
}
inline ::pg_query::Node* ScalarArrayOpExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* ScalarArrayOpExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.ScalarArrayOpExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ScalarArrayOpExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* ScalarArrayOpExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.ScalarArrayOpExpr.xpr)
  return _internal_mutable_xpr();
}
inline void ScalarArrayOpExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ScalarArrayOpExpr.xpr)
}

// uint32 opno = 2 [json_name = "opno"];
inline void ScalarArrayOpExpr::clear_opno() {
  opno_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ScalarArrayOpExpr::_internal_opno() const {
  return opno_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ScalarArrayOpExpr::opno() const {
  // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.opno)
  return _internal_opno();
}
inline void ScalarArrayOpExpr::_internal_set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opno_ = value;
}
inline void ScalarArrayOpExpr::set_opno(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opno(value);
  // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.opno)
}

// uint32 opfuncid = 3 [json_name = "opfuncid"];
inline void ScalarArrayOpExpr::clear_opfuncid() {
  opfuncid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ScalarArrayOpExpr::_internal_opfuncid() const {
  return opfuncid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ScalarArrayOpExpr::opfuncid() const {
  // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.opfuncid)
  return _internal_opfuncid();
}
inline void ScalarArrayOpExpr::_internal_set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  opfuncid_ = value;
}
inline void ScalarArrayOpExpr::set_opfuncid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_opfuncid(value);
  // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.opfuncid)
}

// bool use_or = 4 [json_name = "useOr"];
inline void ScalarArrayOpExpr::clear_use_or() {
  use_or_ = false;
}
inline bool ScalarArrayOpExpr::_internal_use_or() const {
  return use_or_;
}
inline bool ScalarArrayOpExpr::use_or() const {
  // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.use_or)
  return _internal_use_or();
}
inline void ScalarArrayOpExpr::_internal_set_use_or(bool value) {
  
  use_or_ = value;
}
inline void ScalarArrayOpExpr::set_use_or(bool value) {
  _internal_set_use_or(value);
  // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.use_or)
}

// uint32 inputcollid = 5 [json_name = "inputcollid"];
inline void ScalarArrayOpExpr::clear_inputcollid() {
  inputcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ScalarArrayOpExpr::_internal_inputcollid() const {
  return inputcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ScalarArrayOpExpr::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.inputcollid)
  return _internal_inputcollid();
}
inline void ScalarArrayOpExpr::_internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  inputcollid_ = value;
}
inline void ScalarArrayOpExpr::set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.inputcollid)
}

// repeated .pg_query.Node args = 6 [json_name = "args"];
inline int ScalarArrayOpExpr::_internal_args_size() const {
  return args_.size();
}
inline int ScalarArrayOpExpr::args_size() const {
  return _internal_args_size();
}
inline void ScalarArrayOpExpr::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* ScalarArrayOpExpr::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ScalarArrayOpExpr.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ScalarArrayOpExpr::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ScalarArrayOpExpr.args)
  return &args_;
}
inline const ::pg_query::Node& ScalarArrayOpExpr::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& ScalarArrayOpExpr::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.args)
  return _internal_args(index);
}
inline ::pg_query::Node* ScalarArrayOpExpr::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* ScalarArrayOpExpr::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.ScalarArrayOpExpr.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ScalarArrayOpExpr::args() const {
  // @@protoc_insertion_point(field_list:pg_query.ScalarArrayOpExpr.args)
  return args_;
}

// int32 location = 7 [json_name = "location"];
inline void ScalarArrayOpExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ScalarArrayOpExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ScalarArrayOpExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.location)
  return _internal_location();
}
inline void ScalarArrayOpExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void ScalarArrayOpExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.location)
}

// -------------------------------------------------------------------

// BoolExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool BoolExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool BoolExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void BoolExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& BoolExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& BoolExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.BoolExpr.xpr)
  return _internal_xpr();
}
inline void BoolExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.BoolExpr.xpr)
}
inline ::pg_query::Node* BoolExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* BoolExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.BoolExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* BoolExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* BoolExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.BoolExpr.xpr)
  return _internal_mutable_xpr();
}
inline void BoolExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.BoolExpr.xpr)
}

// .pg_query.BoolExprType boolop = 2 [json_name = "boolop"];
inline void BoolExpr::clear_boolop() {
  boolop_ = 0;
}
inline ::pg_query::BoolExprType BoolExpr::_internal_boolop() const {
  return static_cast< ::pg_query::BoolExprType >(boolop_);
}
inline ::pg_query::BoolExprType BoolExpr::boolop() const {
  // @@protoc_insertion_point(field_get:pg_query.BoolExpr.boolop)
  return _internal_boolop();
}
inline void BoolExpr::_internal_set_boolop(::pg_query::BoolExprType value) {
  
  boolop_ = value;
}
inline void BoolExpr::set_boolop(::pg_query::BoolExprType value) {
  _internal_set_boolop(value);
  // @@protoc_insertion_point(field_set:pg_query.BoolExpr.boolop)
}

// repeated .pg_query.Node args = 3 [json_name = "args"];
inline int BoolExpr::_internal_args_size() const {
  return args_.size();
}
inline int BoolExpr::args_size() const {
  return _internal_args_size();
}
inline void BoolExpr::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* BoolExpr::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.BoolExpr.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
BoolExpr::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.BoolExpr.args)
  return &args_;
}
inline const ::pg_query::Node& BoolExpr::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& BoolExpr::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.BoolExpr.args)
  return _internal_args(index);
}
inline ::pg_query::Node* BoolExpr::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* BoolExpr::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.BoolExpr.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
BoolExpr::args() const {
  // @@protoc_insertion_point(field_list:pg_query.BoolExpr.args)
  return args_;
}

// int32 location = 4 [json_name = "location"];
inline void BoolExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 BoolExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 BoolExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.BoolExpr.location)
  return _internal_location();
}
inline void BoolExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void BoolExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.BoolExpr.location)
}

// -------------------------------------------------------------------

// SubLink

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool SubLink::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool SubLink::has_xpr() const {
  return _internal_has_xpr();
}
inline void SubLink::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& SubLink::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubLink::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.SubLink.xpr)
  return _internal_xpr();
}
inline void SubLink::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubLink.xpr)
}
inline ::pg_query::Node* SubLink::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SubLink::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.SubLink.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubLink::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* SubLink::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.SubLink.xpr)
  return _internal_mutable_xpr();
}
inline void SubLink::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SubLink.xpr)
}

// .pg_query.SubLinkType sub_link_type = 2 [json_name = "subLinkType"];
inline void SubLink::clear_sub_link_type() {
  sub_link_type_ = 0;
}
inline ::pg_query::SubLinkType SubLink::_internal_sub_link_type() const {
  return static_cast< ::pg_query::SubLinkType >(sub_link_type_);
}
inline ::pg_query::SubLinkType SubLink::sub_link_type() const {
  // @@protoc_insertion_point(field_get:pg_query.SubLink.sub_link_type)
  return _internal_sub_link_type();
}
inline void SubLink::_internal_set_sub_link_type(::pg_query::SubLinkType value) {
  
  sub_link_type_ = value;
}
inline void SubLink::set_sub_link_type(::pg_query::SubLinkType value) {
  _internal_set_sub_link_type(value);
  // @@protoc_insertion_point(field_set:pg_query.SubLink.sub_link_type)
}

// int32 sub_link_id = 3 [json_name = "subLinkId"];
inline void SubLink::clear_sub_link_id() {
  sub_link_id_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SubLink::_internal_sub_link_id() const {
  return sub_link_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SubLink::sub_link_id() const {
  // @@protoc_insertion_point(field_get:pg_query.SubLink.sub_link_id)
  return _internal_sub_link_id();
}
inline void SubLink::_internal_set_sub_link_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  sub_link_id_ = value;
}
inline void SubLink::set_sub_link_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_sub_link_id(value);
  // @@protoc_insertion_point(field_set:pg_query.SubLink.sub_link_id)
}

// .pg_query.Node testexpr = 4 [json_name = "testexpr"];
inline bool SubLink::_internal_has_testexpr() const {
  return this != internal_default_instance() && testexpr_ != nullptr;
}
inline bool SubLink::has_testexpr() const {
  return _internal_has_testexpr();
}
inline void SubLink::clear_testexpr() {
  if (GetArena() == nullptr && testexpr_ != nullptr) {
    delete testexpr_;
  }
  testexpr_ = nullptr;
}
inline const ::pg_query::Node& SubLink::_internal_testexpr() const {
  const ::pg_query::Node* p = testexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubLink::testexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.SubLink.testexpr)
  return _internal_testexpr();
}
inline void SubLink::unsafe_arena_set_allocated_testexpr(
    ::pg_query::Node* testexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(testexpr_);
  }
  testexpr_ = testexpr;
  if (testexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubLink.testexpr)
}
inline ::pg_query::Node* SubLink::release_testexpr() {
  
  ::pg_query::Node* temp = testexpr_;
  testexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SubLink::unsafe_arena_release_testexpr() {
  // @@protoc_insertion_point(field_release:pg_query.SubLink.testexpr)
  
  ::pg_query::Node* temp = testexpr_;
  testexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubLink::_internal_mutable_testexpr() {
  
  if (testexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    testexpr_ = p;
  }
  return testexpr_;
}
inline ::pg_query::Node* SubLink::mutable_testexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.SubLink.testexpr)
  return _internal_mutable_testexpr();
}
inline void SubLink::set_allocated_testexpr(::pg_query::Node* testexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete testexpr_;
  }
  if (testexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(testexpr);
    if (message_arena != submessage_arena) {
      testexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, testexpr, submessage_arena);
    }
    
  } else {
    
  }
  testexpr_ = testexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SubLink.testexpr)
}

// repeated .pg_query.Node oper_name = 5 [json_name = "operName"];
inline int SubLink::_internal_oper_name_size() const {
  return oper_name_.size();
}
inline int SubLink::oper_name_size() const {
  return _internal_oper_name_size();
}
inline void SubLink::clear_oper_name() {
  oper_name_.Clear();
}
inline ::pg_query::Node* SubLink::mutable_oper_name(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SubLink.oper_name)
  return oper_name_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SubLink::mutable_oper_name() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubLink.oper_name)
  return &oper_name_;
}
inline const ::pg_query::Node& SubLink::_internal_oper_name(int index) const {
  return oper_name_.Get(index);
}
inline const ::pg_query::Node& SubLink::oper_name(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SubLink.oper_name)
  return _internal_oper_name(index);
}
inline ::pg_query::Node* SubLink::_internal_add_oper_name() {
  return oper_name_.Add();
}
inline ::pg_query::Node* SubLink::add_oper_name() {
  // @@protoc_insertion_point(field_add:pg_query.SubLink.oper_name)
  return _internal_add_oper_name();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SubLink::oper_name() const {
  // @@protoc_insertion_point(field_list:pg_query.SubLink.oper_name)
  return oper_name_;
}

// .pg_query.Node subselect = 6 [json_name = "subselect"];
inline bool SubLink::_internal_has_subselect() const {
  return this != internal_default_instance() && subselect_ != nullptr;
}
inline bool SubLink::has_subselect() const {
  return _internal_has_subselect();
}
inline void SubLink::clear_subselect() {
  if (GetArena() == nullptr && subselect_ != nullptr) {
    delete subselect_;
  }
  subselect_ = nullptr;
}
inline const ::pg_query::Node& SubLink::_internal_subselect() const {
  const ::pg_query::Node* p = subselect_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubLink::subselect() const {
  // @@protoc_insertion_point(field_get:pg_query.SubLink.subselect)
  return _internal_subselect();
}
inline void SubLink::unsafe_arena_set_allocated_subselect(
    ::pg_query::Node* subselect) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(subselect_);
  }
  subselect_ = subselect;
  if (subselect) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubLink.subselect)
}
inline ::pg_query::Node* SubLink::release_subselect() {
  
  ::pg_query::Node* temp = subselect_;
  subselect_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SubLink::unsafe_arena_release_subselect() {
  // @@protoc_insertion_point(field_release:pg_query.SubLink.subselect)
  
  ::pg_query::Node* temp = subselect_;
  subselect_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubLink::_internal_mutable_subselect() {
  
  if (subselect_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    subselect_ = p;
  }
  return subselect_;
}
inline ::pg_query::Node* SubLink::mutable_subselect() {
  // @@protoc_insertion_point(field_mutable:pg_query.SubLink.subselect)
  return _internal_mutable_subselect();
}
inline void SubLink::set_allocated_subselect(::pg_query::Node* subselect) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete subselect_;
  }
  if (subselect) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(subselect);
    if (message_arena != submessage_arena) {
      subselect = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, subselect, submessage_arena);
    }
    
  } else {
    
  }
  subselect_ = subselect;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SubLink.subselect)
}

// int32 location = 7 [json_name = "location"];
inline void SubLink::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SubLink::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SubLink::location() const {
  // @@protoc_insertion_point(field_get:pg_query.SubLink.location)
  return _internal_location();
}
inline void SubLink::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void SubLink::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.SubLink.location)
}

// -------------------------------------------------------------------

// SubPlan

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool SubPlan::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool SubPlan::has_xpr() const {
  return _internal_has_xpr();
}
inline void SubPlan::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& SubPlan::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubPlan::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.xpr)
  return _internal_xpr();
}
inline void SubPlan::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubPlan.xpr)
}
inline ::pg_query::Node* SubPlan::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SubPlan::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.SubPlan.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubPlan::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* SubPlan::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.xpr)
  return _internal_mutable_xpr();
}
inline void SubPlan::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SubPlan.xpr)
}

// .pg_query.SubLinkType sub_link_type = 2 [json_name = "subLinkType"];
inline void SubPlan::clear_sub_link_type() {
  sub_link_type_ = 0;
}
inline ::pg_query::SubLinkType SubPlan::_internal_sub_link_type() const {
  return static_cast< ::pg_query::SubLinkType >(sub_link_type_);
}
inline ::pg_query::SubLinkType SubPlan::sub_link_type() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.sub_link_type)
  return _internal_sub_link_type();
}
inline void SubPlan::_internal_set_sub_link_type(::pg_query::SubLinkType value) {
  
  sub_link_type_ = value;
}
inline void SubPlan::set_sub_link_type(::pg_query::SubLinkType value) {
  _internal_set_sub_link_type(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.sub_link_type)
}

// .pg_query.Node testexpr = 3 [json_name = "testexpr"];
inline bool SubPlan::_internal_has_testexpr() const {
  return this != internal_default_instance() && testexpr_ != nullptr;
}
inline bool SubPlan::has_testexpr() const {
  return _internal_has_testexpr();
}
inline void SubPlan::clear_testexpr() {
  if (GetArena() == nullptr && testexpr_ != nullptr) {
    delete testexpr_;
  }
  testexpr_ = nullptr;
}
inline const ::pg_query::Node& SubPlan::_internal_testexpr() const {
  const ::pg_query::Node* p = testexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubPlan::testexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.testexpr)
  return _internal_testexpr();
}
inline void SubPlan::unsafe_arena_set_allocated_testexpr(
    ::pg_query::Node* testexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(testexpr_);
  }
  testexpr_ = testexpr;
  if (testexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubPlan.testexpr)
}
inline ::pg_query::Node* SubPlan::release_testexpr() {
  
  ::pg_query::Node* temp = testexpr_;
  testexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SubPlan::unsafe_arena_release_testexpr() {
  // @@protoc_insertion_point(field_release:pg_query.SubPlan.testexpr)
  
  ::pg_query::Node* temp = testexpr_;
  testexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubPlan::_internal_mutable_testexpr() {
  
  if (testexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    testexpr_ = p;
  }
  return testexpr_;
}
inline ::pg_query::Node* SubPlan::mutable_testexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.testexpr)
  return _internal_mutable_testexpr();
}
inline void SubPlan::set_allocated_testexpr(::pg_query::Node* testexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete testexpr_;
  }
  if (testexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(testexpr);
    if (message_arena != submessage_arena) {
      testexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, testexpr, submessage_arena);
    }
    
  } else {
    
  }
  testexpr_ = testexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SubPlan.testexpr)
}

// repeated .pg_query.Node param_ids = 4 [json_name = "paramIds"];
inline int SubPlan::_internal_param_ids_size() const {
  return param_ids_.size();
}
inline int SubPlan::param_ids_size() const {
  return _internal_param_ids_size();
}
inline void SubPlan::clear_param_ids() {
  param_ids_.Clear();
}
inline ::pg_query::Node* SubPlan::mutable_param_ids(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.param_ids)
  return param_ids_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SubPlan::mutable_param_ids() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubPlan.param_ids)
  return &param_ids_;
}
inline const ::pg_query::Node& SubPlan::_internal_param_ids(int index) const {
  return param_ids_.Get(index);
}
inline const ::pg_query::Node& SubPlan::param_ids(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.param_ids)
  return _internal_param_ids(index);
}
inline ::pg_query::Node* SubPlan::_internal_add_param_ids() {
  return param_ids_.Add();
}
inline ::pg_query::Node* SubPlan::add_param_ids() {
  // @@protoc_insertion_point(field_add:pg_query.SubPlan.param_ids)
  return _internal_add_param_ids();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SubPlan::param_ids() const {
  // @@protoc_insertion_point(field_list:pg_query.SubPlan.param_ids)
  return param_ids_;
}

// int32 plan_id = 5 [json_name = "plan_id"];
inline void SubPlan::clear_plan_id() {
  plan_id_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SubPlan::_internal_plan_id() const {
  return plan_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SubPlan::plan_id() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.plan_id)
  return _internal_plan_id();
}
inline void SubPlan::_internal_set_plan_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  plan_id_ = value;
}
inline void SubPlan::set_plan_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_plan_id(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.plan_id)
}

// string plan_name = 6 [json_name = "plan_name"];
inline void SubPlan::clear_plan_name() {
  plan_name_.ClearToEmpty();
}
inline const std::string& SubPlan::plan_name() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.plan_name)
  return _internal_plan_name();
}
inline void SubPlan::set_plan_name(const std::string& value) {
  _internal_set_plan_name(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.plan_name)
}
inline std::string* SubPlan::mutable_plan_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.plan_name)
  return _internal_mutable_plan_name();
}
inline const std::string& SubPlan::_internal_plan_name() const {
  return plan_name_.Get();
}
inline void SubPlan::_internal_set_plan_name(const std::string& value) {
  
  plan_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SubPlan::set_plan_name(std::string&& value) {
  
  plan_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.SubPlan.plan_name)
}
inline void SubPlan::set_plan_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  plan_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.SubPlan.plan_name)
}
inline void SubPlan::set_plan_name(const char* value,
    size_t size) {
  
  plan_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.SubPlan.plan_name)
}
inline std::string* SubPlan::_internal_mutable_plan_name() {
  
  return plan_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SubPlan::release_plan_name() {
  // @@protoc_insertion_point(field_release:pg_query.SubPlan.plan_name)
  return plan_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SubPlan::set_allocated_plan_name(std::string* plan_name) {
  if (plan_name != nullptr) {
    
  } else {
    
  }
  plan_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), plan_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.SubPlan.plan_name)
}

// uint32 first_col_type = 7 [json_name = "firstColType"];
inline void SubPlan::clear_first_col_type() {
  first_col_type_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SubPlan::_internal_first_col_type() const {
  return first_col_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SubPlan::first_col_type() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.first_col_type)
  return _internal_first_col_type();
}
inline void SubPlan::_internal_set_first_col_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  first_col_type_ = value;
}
inline void SubPlan::set_first_col_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_first_col_type(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.first_col_type)
}

// int32 first_col_typmod = 8 [json_name = "firstColTypmod"];
inline void SubPlan::clear_first_col_typmod() {
  first_col_typmod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SubPlan::_internal_first_col_typmod() const {
  return first_col_typmod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SubPlan::first_col_typmod() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.first_col_typmod)
  return _internal_first_col_typmod();
}
inline void SubPlan::_internal_set_first_col_typmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  first_col_typmod_ = value;
}
inline void SubPlan::set_first_col_typmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_first_col_typmod(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.first_col_typmod)
}

// uint32 first_col_collation = 9 [json_name = "firstColCollation"];
inline void SubPlan::clear_first_col_collation() {
  first_col_collation_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SubPlan::_internal_first_col_collation() const {
  return first_col_collation_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SubPlan::first_col_collation() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.first_col_collation)
  return _internal_first_col_collation();
}
inline void SubPlan::_internal_set_first_col_collation(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  first_col_collation_ = value;
}
inline void SubPlan::set_first_col_collation(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_first_col_collation(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.first_col_collation)
}

// bool use_hash_table = 10 [json_name = "useHashTable"];
inline void SubPlan::clear_use_hash_table() {
  use_hash_table_ = false;
}
inline bool SubPlan::_internal_use_hash_table() const {
  return use_hash_table_;
}
inline bool SubPlan::use_hash_table() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.use_hash_table)
  return _internal_use_hash_table();
}
inline void SubPlan::_internal_set_use_hash_table(bool value) {
  
  use_hash_table_ = value;
}
inline void SubPlan::set_use_hash_table(bool value) {
  _internal_set_use_hash_table(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.use_hash_table)
}

// bool unknown_eq_false = 11 [json_name = "unknownEqFalse"];
inline void SubPlan::clear_unknown_eq_false() {
  unknown_eq_false_ = false;
}
inline bool SubPlan::_internal_unknown_eq_false() const {
  return unknown_eq_false_;
}
inline bool SubPlan::unknown_eq_false() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.unknown_eq_false)
  return _internal_unknown_eq_false();
}
inline void SubPlan::_internal_set_unknown_eq_false(bool value) {
  
  unknown_eq_false_ = value;
}
inline void SubPlan::set_unknown_eq_false(bool value) {
  _internal_set_unknown_eq_false(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.unknown_eq_false)
}

// bool parallel_safe = 12 [json_name = "parallel_safe"];
inline void SubPlan::clear_parallel_safe() {
  parallel_safe_ = false;
}
inline bool SubPlan::_internal_parallel_safe() const {
  return parallel_safe_;
}
inline bool SubPlan::parallel_safe() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.parallel_safe)
  return _internal_parallel_safe();
}
inline void SubPlan::_internal_set_parallel_safe(bool value) {
  
  parallel_safe_ = value;
}
inline void SubPlan::set_parallel_safe(bool value) {
  _internal_set_parallel_safe(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.parallel_safe)
}

// repeated .pg_query.Node set_param = 13 [json_name = "setParam"];
inline int SubPlan::_internal_set_param_size() const {
  return set_param_.size();
}
inline int SubPlan::set_param_size() const {
  return _internal_set_param_size();
}
inline void SubPlan::clear_set_param() {
  set_param_.Clear();
}
inline ::pg_query::Node* SubPlan::mutable_set_param(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.set_param)
  return set_param_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SubPlan::mutable_set_param() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubPlan.set_param)
  return &set_param_;
}
inline const ::pg_query::Node& SubPlan::_internal_set_param(int index) const {
  return set_param_.Get(index);
}
inline const ::pg_query::Node& SubPlan::set_param(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.set_param)
  return _internal_set_param(index);
}
inline ::pg_query::Node* SubPlan::_internal_add_set_param() {
  return set_param_.Add();
}
inline ::pg_query::Node* SubPlan::add_set_param() {
  // @@protoc_insertion_point(field_add:pg_query.SubPlan.set_param)
  return _internal_add_set_param();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SubPlan::set_param() const {
  // @@protoc_insertion_point(field_list:pg_query.SubPlan.set_param)
  return set_param_;
}

// repeated .pg_query.Node par_param = 14 [json_name = "parParam"];
inline int SubPlan::_internal_par_param_size() const {
  return par_param_.size();
}
inline int SubPlan::par_param_size() const {
  return _internal_par_param_size();
}
inline void SubPlan::clear_par_param() {
  par_param_.Clear();
}
inline ::pg_query::Node* SubPlan::mutable_par_param(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.par_param)
  return par_param_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SubPlan::mutable_par_param() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubPlan.par_param)
  return &par_param_;
}
inline const ::pg_query::Node& SubPlan::_internal_par_param(int index) const {
  return par_param_.Get(index);
}
inline const ::pg_query::Node& SubPlan::par_param(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.par_param)
  return _internal_par_param(index);
}
inline ::pg_query::Node* SubPlan::_internal_add_par_param() {
  return par_param_.Add();
}
inline ::pg_query::Node* SubPlan::add_par_param() {
  // @@protoc_insertion_point(field_add:pg_query.SubPlan.par_param)
  return _internal_add_par_param();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SubPlan::par_param() const {
  // @@protoc_insertion_point(field_list:pg_query.SubPlan.par_param)
  return par_param_;
}

// repeated .pg_query.Node args = 15 [json_name = "args"];
inline int SubPlan::_internal_args_size() const {
  return args_.size();
}
inline int SubPlan::args_size() const {
  return _internal_args_size();
}
inline void SubPlan::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* SubPlan::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SubPlan::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubPlan.args)
  return &args_;
}
inline const ::pg_query::Node& SubPlan::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& SubPlan::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.args)
  return _internal_args(index);
}
inline ::pg_query::Node* SubPlan::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* SubPlan::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.SubPlan.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SubPlan::args() const {
  // @@protoc_insertion_point(field_list:pg_query.SubPlan.args)
  return args_;
}

// double startup_cost = 16 [json_name = "startup_cost"];
inline void SubPlan::clear_startup_cost() {
  startup_cost_ = 0;
}
inline double SubPlan::_internal_startup_cost() const {
  return startup_cost_;
}
inline double SubPlan::startup_cost() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.startup_cost)
  return _internal_startup_cost();
}
inline void SubPlan::_internal_set_startup_cost(double value) {
  
  startup_cost_ = value;
}
inline void SubPlan::set_startup_cost(double value) {
  _internal_set_startup_cost(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.startup_cost)
}

// double per_call_cost = 17 [json_name = "per_call_cost"];
inline void SubPlan::clear_per_call_cost() {
  per_call_cost_ = 0;
}
inline double SubPlan::_internal_per_call_cost() const {
  return per_call_cost_;
}
inline double SubPlan::per_call_cost() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.per_call_cost)
  return _internal_per_call_cost();
}
inline void SubPlan::_internal_set_per_call_cost(double value) {
  
  per_call_cost_ = value;
}
inline void SubPlan::set_per_call_cost(double value) {
  _internal_set_per_call_cost(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.per_call_cost)
}

// -------------------------------------------------------------------

// AlternativeSubPlan

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool AlternativeSubPlan::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool AlternativeSubPlan::has_xpr() const {
  return _internal_has_xpr();
}
inline void AlternativeSubPlan::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& AlternativeSubPlan::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlternativeSubPlan::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.AlternativeSubPlan.xpr)
  return _internal_xpr();
}
inline void AlternativeSubPlan::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlternativeSubPlan.xpr)
}
inline ::pg_query::Node* AlternativeSubPlan::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* AlternativeSubPlan::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.AlternativeSubPlan.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlternativeSubPlan::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* AlternativeSubPlan::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlternativeSubPlan.xpr)
  return _internal_mutable_xpr();
}
inline void AlternativeSubPlan::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlternativeSubPlan.xpr)
}

// repeated .pg_query.Node subplans = 2 [json_name = "subplans"];
inline int AlternativeSubPlan::_internal_subplans_size() const {
  return subplans_.size();
}
inline int AlternativeSubPlan::subplans_size() const {
  return _internal_subplans_size();
}
inline void AlternativeSubPlan::clear_subplans() {
  subplans_.Clear();
}
inline ::pg_query::Node* AlternativeSubPlan::mutable_subplans(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlternativeSubPlan.subplans)
  return subplans_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlternativeSubPlan::mutable_subplans() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlternativeSubPlan.subplans)
  return &subplans_;
}
inline const ::pg_query::Node& AlternativeSubPlan::_internal_subplans(int index) const {
  return subplans_.Get(index);
}
inline const ::pg_query::Node& AlternativeSubPlan::subplans(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlternativeSubPlan.subplans)
  return _internal_subplans(index);
}
inline ::pg_query::Node* AlternativeSubPlan::_internal_add_subplans() {
  return subplans_.Add();
}
inline ::pg_query::Node* AlternativeSubPlan::add_subplans() {
  // @@protoc_insertion_point(field_add:pg_query.AlternativeSubPlan.subplans)
  return _internal_add_subplans();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlternativeSubPlan::subplans() const {
  // @@protoc_insertion_point(field_list:pg_query.AlternativeSubPlan.subplans)
  return subplans_;
}

// -------------------------------------------------------------------

// FieldSelect

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool FieldSelect::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool FieldSelect::has_xpr() const {
  return _internal_has_xpr();
}
inline void FieldSelect::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& FieldSelect::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FieldSelect::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldSelect.xpr)
  return _internal_xpr();
}
inline void FieldSelect::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FieldSelect.xpr)
}
inline ::pg_query::Node* FieldSelect::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* FieldSelect::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.FieldSelect.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FieldSelect::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* FieldSelect::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.FieldSelect.xpr)
  return _internal_mutable_xpr();
}
inline void FieldSelect::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.FieldSelect.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool FieldSelect::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool FieldSelect::has_arg() const {
  return _internal_has_arg();
}
inline void FieldSelect::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& FieldSelect::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FieldSelect::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldSelect.arg)
  return _internal_arg();
}
inline void FieldSelect::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FieldSelect.arg)
}
inline ::pg_query::Node* FieldSelect::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* FieldSelect::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.FieldSelect.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FieldSelect::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* FieldSelect::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.FieldSelect.arg)
  return _internal_mutable_arg();
}
inline void FieldSelect::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.FieldSelect.arg)
}

// int32 fieldnum = 3 [json_name = "fieldnum"];
inline void FieldSelect::clear_fieldnum() {
  fieldnum_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FieldSelect::_internal_fieldnum() const {
  return fieldnum_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FieldSelect::fieldnum() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldSelect.fieldnum)
  return _internal_fieldnum();
}
inline void FieldSelect::_internal_set_fieldnum(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  fieldnum_ = value;
}
inline void FieldSelect::set_fieldnum(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_fieldnum(value);
  // @@protoc_insertion_point(field_set:pg_query.FieldSelect.fieldnum)
}

// uint32 resulttype = 4 [json_name = "resulttype"];
inline void FieldSelect::clear_resulttype() {
  resulttype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FieldSelect::_internal_resulttype() const {
  return resulttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FieldSelect::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldSelect.resulttype)
  return _internal_resulttype();
}
inline void FieldSelect::_internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  resulttype_ = value;
}
inline void FieldSelect::set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.FieldSelect.resulttype)
}

// int32 resulttypmod = 5 [json_name = "resulttypmod"];
inline void FieldSelect::clear_resulttypmod() {
  resulttypmod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FieldSelect::_internal_resulttypmod() const {
  return resulttypmod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FieldSelect::resulttypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldSelect.resulttypmod)
  return _internal_resulttypmod();
}
inline void FieldSelect::_internal_set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  resulttypmod_ = value;
}
inline void FieldSelect::set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_resulttypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.FieldSelect.resulttypmod)
}

// uint32 resultcollid = 6 [json_name = "resultcollid"];
inline void FieldSelect::clear_resultcollid() {
  resultcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FieldSelect::_internal_resultcollid() const {
  return resultcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FieldSelect::resultcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldSelect.resultcollid)
  return _internal_resultcollid();
}
inline void FieldSelect::_internal_set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  resultcollid_ = value;
}
inline void FieldSelect::set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resultcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.FieldSelect.resultcollid)
}

// -------------------------------------------------------------------

// FieldStore

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool FieldStore::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool FieldStore::has_xpr() const {
  return _internal_has_xpr();
}
inline void FieldStore::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& FieldStore::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FieldStore::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldStore.xpr)
  return _internal_xpr();
}
inline void FieldStore::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FieldStore.xpr)
}
inline ::pg_query::Node* FieldStore::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* FieldStore::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.FieldStore.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FieldStore::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* FieldStore::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.FieldStore.xpr)
  return _internal_mutable_xpr();
}
inline void FieldStore::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.FieldStore.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool FieldStore::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool FieldStore::has_arg() const {
  return _internal_has_arg();
}
inline void FieldStore::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& FieldStore::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FieldStore::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldStore.arg)
  return _internal_arg();
}
inline void FieldStore::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FieldStore.arg)
}
inline ::pg_query::Node* FieldStore::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* FieldStore::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.FieldStore.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FieldStore::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* FieldStore::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.FieldStore.arg)
  return _internal_mutable_arg();
}
inline void FieldStore::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.FieldStore.arg)
}

// repeated .pg_query.Node newvals = 3 [json_name = "newvals"];
inline int FieldStore::_internal_newvals_size() const {
  return newvals_.size();
}
inline int FieldStore::newvals_size() const {
  return _internal_newvals_size();
}
inline void FieldStore::clear_newvals() {
  newvals_.Clear();
}
inline ::pg_query::Node* FieldStore::mutable_newvals(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.FieldStore.newvals)
  return newvals_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
FieldStore::mutable_newvals() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FieldStore.newvals)
  return &newvals_;
}
inline const ::pg_query::Node& FieldStore::_internal_newvals(int index) const {
  return newvals_.Get(index);
}
inline const ::pg_query::Node& FieldStore::newvals(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.FieldStore.newvals)
  return _internal_newvals(index);
}
inline ::pg_query::Node* FieldStore::_internal_add_newvals() {
  return newvals_.Add();
}
inline ::pg_query::Node* FieldStore::add_newvals() {
  // @@protoc_insertion_point(field_add:pg_query.FieldStore.newvals)
  return _internal_add_newvals();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
FieldStore::newvals() const {
  // @@protoc_insertion_point(field_list:pg_query.FieldStore.newvals)
  return newvals_;
}

// repeated .pg_query.Node fieldnums = 4 [json_name = "fieldnums"];
inline int FieldStore::_internal_fieldnums_size() const {
  return fieldnums_.size();
}
inline int FieldStore::fieldnums_size() const {
  return _internal_fieldnums_size();
}
inline void FieldStore::clear_fieldnums() {
  fieldnums_.Clear();
}
inline ::pg_query::Node* FieldStore::mutable_fieldnums(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.FieldStore.fieldnums)
  return fieldnums_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
FieldStore::mutable_fieldnums() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FieldStore.fieldnums)
  return &fieldnums_;
}
inline const ::pg_query::Node& FieldStore::_internal_fieldnums(int index) const {
  return fieldnums_.Get(index);
}
inline const ::pg_query::Node& FieldStore::fieldnums(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.FieldStore.fieldnums)
  return _internal_fieldnums(index);
}
inline ::pg_query::Node* FieldStore::_internal_add_fieldnums() {
  return fieldnums_.Add();
}
inline ::pg_query::Node* FieldStore::add_fieldnums() {
  // @@protoc_insertion_point(field_add:pg_query.FieldStore.fieldnums)
  return _internal_add_fieldnums();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
FieldStore::fieldnums() const {
  // @@protoc_insertion_point(field_list:pg_query.FieldStore.fieldnums)
  return fieldnums_;
}

// uint32 resulttype = 5 [json_name = "resulttype"];
inline void FieldStore::clear_resulttype() {
  resulttype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FieldStore::_internal_resulttype() const {
  return resulttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FieldStore::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldStore.resulttype)
  return _internal_resulttype();
}
inline void FieldStore::_internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  resulttype_ = value;
}
inline void FieldStore::set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.FieldStore.resulttype)
}

// -------------------------------------------------------------------

// RelabelType

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool RelabelType::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool RelabelType::has_xpr() const {
  return _internal_has_xpr();
}
inline void RelabelType::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& RelabelType::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RelabelType::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.xpr)
  return _internal_xpr();
}
inline void RelabelType::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RelabelType.xpr)
}
inline ::pg_query::Node* RelabelType::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RelabelType::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.RelabelType.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RelabelType::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* RelabelType::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.RelabelType.xpr)
  return _internal_mutable_xpr();
}
inline void RelabelType::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RelabelType.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool RelabelType::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool RelabelType::has_arg() const {
  return _internal_has_arg();
}
inline void RelabelType::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& RelabelType::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RelabelType::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.arg)
  return _internal_arg();
}
inline void RelabelType::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RelabelType.arg)
}
inline ::pg_query::Node* RelabelType::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RelabelType::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.RelabelType.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RelabelType::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* RelabelType::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.RelabelType.arg)
  return _internal_mutable_arg();
}
inline void RelabelType::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RelabelType.arg)
}

// uint32 resulttype = 3 [json_name = "resulttype"];
inline void RelabelType::clear_resulttype() {
  resulttype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RelabelType::_internal_resulttype() const {
  return resulttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RelabelType::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.resulttype)
  return _internal_resulttype();
}
inline void RelabelType::_internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  resulttype_ = value;
}
inline void RelabelType::set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.RelabelType.resulttype)
}

// int32 resulttypmod = 4 [json_name = "resulttypmod"];
inline void RelabelType::clear_resulttypmod() {
  resulttypmod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RelabelType::_internal_resulttypmod() const {
  return resulttypmod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RelabelType::resulttypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.resulttypmod)
  return _internal_resulttypmod();
}
inline void RelabelType::_internal_set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  resulttypmod_ = value;
}
inline void RelabelType::set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_resulttypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.RelabelType.resulttypmod)
}

// uint32 resultcollid = 5 [json_name = "resultcollid"];
inline void RelabelType::clear_resultcollid() {
  resultcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RelabelType::_internal_resultcollid() const {
  return resultcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RelabelType::resultcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.resultcollid)
  return _internal_resultcollid();
}
inline void RelabelType::_internal_set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  resultcollid_ = value;
}
inline void RelabelType::set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resultcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.RelabelType.resultcollid)
}

// .pg_query.CoercionForm relabelformat = 6 [json_name = "relabelformat"];
inline void RelabelType::clear_relabelformat() {
  relabelformat_ = 0;
}
inline ::pg_query::CoercionForm RelabelType::_internal_relabelformat() const {
  return static_cast< ::pg_query::CoercionForm >(relabelformat_);
}
inline ::pg_query::CoercionForm RelabelType::relabelformat() const {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.relabelformat)
  return _internal_relabelformat();
}
inline void RelabelType::_internal_set_relabelformat(::pg_query::CoercionForm value) {
  
  relabelformat_ = value;
}
inline void RelabelType::set_relabelformat(::pg_query::CoercionForm value) {
  _internal_set_relabelformat(value);
  // @@protoc_insertion_point(field_set:pg_query.RelabelType.relabelformat)
}

// int32 location = 7 [json_name = "location"];
inline void RelabelType::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RelabelType::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RelabelType::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.location)
  return _internal_location();
}
inline void RelabelType::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void RelabelType::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RelabelType.location)
}

// -------------------------------------------------------------------

// CoerceViaIO

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CoerceViaIO::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool CoerceViaIO::has_xpr() const {
  return _internal_has_xpr();
}
inline void CoerceViaIO::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& CoerceViaIO::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CoerceViaIO::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.xpr)
  return _internal_xpr();
}
inline void CoerceViaIO::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceViaIO.xpr)
}
inline ::pg_query::Node* CoerceViaIO::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CoerceViaIO::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.CoerceViaIO.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CoerceViaIO::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* CoerceViaIO::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.CoerceViaIO.xpr)
  return _internal_mutable_xpr();
}
inline void CoerceViaIO::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceViaIO.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool CoerceViaIO::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool CoerceViaIO::has_arg() const {
  return _internal_has_arg();
}
inline void CoerceViaIO::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& CoerceViaIO::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CoerceViaIO::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.arg)
  return _internal_arg();
}
inline void CoerceViaIO::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceViaIO.arg)
}
inline ::pg_query::Node* CoerceViaIO::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CoerceViaIO::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.CoerceViaIO.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CoerceViaIO::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* CoerceViaIO::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.CoerceViaIO.arg)
  return _internal_mutable_arg();
}
inline void CoerceViaIO::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceViaIO.arg)
}

// uint32 resulttype = 3 [json_name = "resulttype"];
inline void CoerceViaIO::clear_resulttype() {
  resulttype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoerceViaIO::_internal_resulttype() const {
  return resulttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoerceViaIO::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.resulttype)
  return _internal_resulttype();
}
inline void CoerceViaIO::_internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  resulttype_ = value;
}
inline void CoerceViaIO::set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceViaIO.resulttype)
}

// uint32 resultcollid = 4 [json_name = "resultcollid"];
inline void CoerceViaIO::clear_resultcollid() {
  resultcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoerceViaIO::_internal_resultcollid() const {
  return resultcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoerceViaIO::resultcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.resultcollid)
  return _internal_resultcollid();
}
inline void CoerceViaIO::_internal_set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  resultcollid_ = value;
}
inline void CoerceViaIO::set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resultcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceViaIO.resultcollid)
}

// .pg_query.CoercionForm coerceformat = 5 [json_name = "coerceformat"];
inline void CoerceViaIO::clear_coerceformat() {
  coerceformat_ = 0;
}
inline ::pg_query::CoercionForm CoerceViaIO::_internal_coerceformat() const {
  return static_cast< ::pg_query::CoercionForm >(coerceformat_);
}
inline ::pg_query::CoercionForm CoerceViaIO::coerceformat() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.coerceformat)
  return _internal_coerceformat();
}
inline void CoerceViaIO::_internal_set_coerceformat(::pg_query::CoercionForm value) {
  
  coerceformat_ = value;
}
inline void CoerceViaIO::set_coerceformat(::pg_query::CoercionForm value) {
  _internal_set_coerceformat(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceViaIO.coerceformat)
}

// int32 location = 6 [json_name = "location"];
inline void CoerceViaIO::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CoerceViaIO::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CoerceViaIO::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.location)
  return _internal_location();
}
inline void CoerceViaIO::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void CoerceViaIO::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceViaIO.location)
}

// -------------------------------------------------------------------

// ArrayCoerceExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool ArrayCoerceExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool ArrayCoerceExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void ArrayCoerceExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& ArrayCoerceExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ArrayCoerceExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.xpr)
  return _internal_xpr();
}
inline void ArrayCoerceExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ArrayCoerceExpr.xpr)
}
inline ::pg_query::Node* ArrayCoerceExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* ArrayCoerceExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.ArrayCoerceExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ArrayCoerceExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* ArrayCoerceExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.ArrayCoerceExpr.xpr)
  return _internal_mutable_xpr();
}
inline void ArrayCoerceExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ArrayCoerceExpr.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool ArrayCoerceExpr::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool ArrayCoerceExpr::has_arg() const {
  return _internal_has_arg();
}
inline void ArrayCoerceExpr::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& ArrayCoerceExpr::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ArrayCoerceExpr::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.arg)
  return _internal_arg();
}
inline void ArrayCoerceExpr::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ArrayCoerceExpr.arg)
}
inline ::pg_query::Node* ArrayCoerceExpr::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* ArrayCoerceExpr::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.ArrayCoerceExpr.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ArrayCoerceExpr::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* ArrayCoerceExpr::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.ArrayCoerceExpr.arg)
  return _internal_mutable_arg();
}
inline void ArrayCoerceExpr::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ArrayCoerceExpr.arg)
}

// .pg_query.Node elemexpr = 3 [json_name = "elemexpr"];
inline bool ArrayCoerceExpr::_internal_has_elemexpr() const {
  return this != internal_default_instance() && elemexpr_ != nullptr;
}
inline bool ArrayCoerceExpr::has_elemexpr() const {
  return _internal_has_elemexpr();
}
inline void ArrayCoerceExpr::clear_elemexpr() {
  if (GetArena() == nullptr && elemexpr_ != nullptr) {
    delete elemexpr_;
  }
  elemexpr_ = nullptr;
}
inline const ::pg_query::Node& ArrayCoerceExpr::_internal_elemexpr() const {
  const ::pg_query::Node* p = elemexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ArrayCoerceExpr::elemexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.elemexpr)
  return _internal_elemexpr();
}
inline void ArrayCoerceExpr::unsafe_arena_set_allocated_elemexpr(
    ::pg_query::Node* elemexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(elemexpr_);
  }
  elemexpr_ = elemexpr;
  if (elemexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ArrayCoerceExpr.elemexpr)
}
inline ::pg_query::Node* ArrayCoerceExpr::release_elemexpr() {
  
  ::pg_query::Node* temp = elemexpr_;
  elemexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* ArrayCoerceExpr::unsafe_arena_release_elemexpr() {
  // @@protoc_insertion_point(field_release:pg_query.ArrayCoerceExpr.elemexpr)
  
  ::pg_query::Node* temp = elemexpr_;
  elemexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ArrayCoerceExpr::_internal_mutable_elemexpr() {
  
  if (elemexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    elemexpr_ = p;
  }
  return elemexpr_;
}
inline ::pg_query::Node* ArrayCoerceExpr::mutable_elemexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.ArrayCoerceExpr.elemexpr)
  return _internal_mutable_elemexpr();
}
inline void ArrayCoerceExpr::set_allocated_elemexpr(::pg_query::Node* elemexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete elemexpr_;
  }
  if (elemexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(elemexpr);
    if (message_arena != submessage_arena) {
      elemexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, elemexpr, submessage_arena);
    }
    
  } else {
    
  }
  elemexpr_ = elemexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ArrayCoerceExpr.elemexpr)
}

// uint32 resulttype = 4 [json_name = "resulttype"];
inline void ArrayCoerceExpr::clear_resulttype() {
  resulttype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ArrayCoerceExpr::_internal_resulttype() const {
  return resulttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ArrayCoerceExpr::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.resulttype)
  return _internal_resulttype();
}
inline void ArrayCoerceExpr::_internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  resulttype_ = value;
}
inline void ArrayCoerceExpr::set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.resulttype)
}

// int32 resulttypmod = 5 [json_name = "resulttypmod"];
inline void ArrayCoerceExpr::clear_resulttypmod() {
  resulttypmod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ArrayCoerceExpr::_internal_resulttypmod() const {
  return resulttypmod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ArrayCoerceExpr::resulttypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.resulttypmod)
  return _internal_resulttypmod();
}
inline void ArrayCoerceExpr::_internal_set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  resulttypmod_ = value;
}
inline void ArrayCoerceExpr::set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_resulttypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.resulttypmod)
}

// uint32 resultcollid = 6 [json_name = "resultcollid"];
inline void ArrayCoerceExpr::clear_resultcollid() {
  resultcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ArrayCoerceExpr::_internal_resultcollid() const {
  return resultcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ArrayCoerceExpr::resultcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.resultcollid)
  return _internal_resultcollid();
}
inline void ArrayCoerceExpr::_internal_set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  resultcollid_ = value;
}
inline void ArrayCoerceExpr::set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resultcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.resultcollid)
}

// .pg_query.CoercionForm coerceformat = 7 [json_name = "coerceformat"];
inline void ArrayCoerceExpr::clear_coerceformat() {
  coerceformat_ = 0;
}
inline ::pg_query::CoercionForm ArrayCoerceExpr::_internal_coerceformat() const {
  return static_cast< ::pg_query::CoercionForm >(coerceformat_);
}
inline ::pg_query::CoercionForm ArrayCoerceExpr::coerceformat() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.coerceformat)
  return _internal_coerceformat();
}
inline void ArrayCoerceExpr::_internal_set_coerceformat(::pg_query::CoercionForm value) {
  
  coerceformat_ = value;
}
inline void ArrayCoerceExpr::set_coerceformat(::pg_query::CoercionForm value) {
  _internal_set_coerceformat(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.coerceformat)
}

// int32 location = 8 [json_name = "location"];
inline void ArrayCoerceExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ArrayCoerceExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ArrayCoerceExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.location)
  return _internal_location();
}
inline void ArrayCoerceExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void ArrayCoerceExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.location)
}

// -------------------------------------------------------------------

// ConvertRowtypeExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool ConvertRowtypeExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool ConvertRowtypeExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void ConvertRowtypeExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& ConvertRowtypeExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ConvertRowtypeExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.xpr)
  return _internal_xpr();
}
inline void ConvertRowtypeExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ConvertRowtypeExpr.xpr)
}
inline ::pg_query::Node* ConvertRowtypeExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* ConvertRowtypeExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.ConvertRowtypeExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ConvertRowtypeExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* ConvertRowtypeExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.ConvertRowtypeExpr.xpr)
  return _internal_mutable_xpr();
}
inline void ConvertRowtypeExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ConvertRowtypeExpr.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool ConvertRowtypeExpr::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool ConvertRowtypeExpr::has_arg() const {
  return _internal_has_arg();
}
inline void ConvertRowtypeExpr::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& ConvertRowtypeExpr::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ConvertRowtypeExpr::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.arg)
  return _internal_arg();
}
inline void ConvertRowtypeExpr::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ConvertRowtypeExpr.arg)
}
inline ::pg_query::Node* ConvertRowtypeExpr::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* ConvertRowtypeExpr::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.ConvertRowtypeExpr.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ConvertRowtypeExpr::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* ConvertRowtypeExpr::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.ConvertRowtypeExpr.arg)
  return _internal_mutable_arg();
}
inline void ConvertRowtypeExpr::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ConvertRowtypeExpr.arg)
}

// uint32 resulttype = 3 [json_name = "resulttype"];
inline void ConvertRowtypeExpr::clear_resulttype() {
  resulttype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ConvertRowtypeExpr::_internal_resulttype() const {
  return resulttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ConvertRowtypeExpr::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.resulttype)
  return _internal_resulttype();
}
inline void ConvertRowtypeExpr::_internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  resulttype_ = value;
}
inline void ConvertRowtypeExpr::set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.ConvertRowtypeExpr.resulttype)
}

// .pg_query.CoercionForm convertformat = 4 [json_name = "convertformat"];
inline void ConvertRowtypeExpr::clear_convertformat() {
  convertformat_ = 0;
}
inline ::pg_query::CoercionForm ConvertRowtypeExpr::_internal_convertformat() const {
  return static_cast< ::pg_query::CoercionForm >(convertformat_);
}
inline ::pg_query::CoercionForm ConvertRowtypeExpr::convertformat() const {
  // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.convertformat)
  return _internal_convertformat();
}
inline void ConvertRowtypeExpr::_internal_set_convertformat(::pg_query::CoercionForm value) {
  
  convertformat_ = value;
}
inline void ConvertRowtypeExpr::set_convertformat(::pg_query::CoercionForm value) {
  _internal_set_convertformat(value);
  // @@protoc_insertion_point(field_set:pg_query.ConvertRowtypeExpr.convertformat)
}

// int32 location = 5 [json_name = "location"];
inline void ConvertRowtypeExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ConvertRowtypeExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ConvertRowtypeExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.location)
  return _internal_location();
}
inline void ConvertRowtypeExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void ConvertRowtypeExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ConvertRowtypeExpr.location)
}

// -------------------------------------------------------------------

// CollateExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CollateExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool CollateExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void CollateExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& CollateExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CollateExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.CollateExpr.xpr)
  return _internal_xpr();
}
inline void CollateExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CollateExpr.xpr)
}
inline ::pg_query::Node* CollateExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CollateExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.CollateExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CollateExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* CollateExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.CollateExpr.xpr)
  return _internal_mutable_xpr();
}
inline void CollateExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CollateExpr.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool CollateExpr::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool CollateExpr::has_arg() const {
  return _internal_has_arg();
}
inline void CollateExpr::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& CollateExpr::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CollateExpr::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.CollateExpr.arg)
  return _internal_arg();
}
inline void CollateExpr::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CollateExpr.arg)
}
inline ::pg_query::Node* CollateExpr::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CollateExpr::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.CollateExpr.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CollateExpr::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* CollateExpr::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.CollateExpr.arg)
  return _internal_mutable_arg();
}
inline void CollateExpr::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CollateExpr.arg)
}

// uint32 coll_oid = 3 [json_name = "collOid"];
inline void CollateExpr::clear_coll_oid() {
  coll_oid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CollateExpr::_internal_coll_oid() const {
  return coll_oid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CollateExpr::coll_oid() const {
  // @@protoc_insertion_point(field_get:pg_query.CollateExpr.coll_oid)
  return _internal_coll_oid();
}
inline void CollateExpr::_internal_set_coll_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  coll_oid_ = value;
}
inline void CollateExpr::set_coll_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_coll_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.CollateExpr.coll_oid)
}

// int32 location = 4 [json_name = "location"];
inline void CollateExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CollateExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CollateExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CollateExpr.location)
  return _internal_location();
}
inline void CollateExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void CollateExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CollateExpr.location)
}

// -------------------------------------------------------------------

// CaseExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CaseExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool CaseExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void CaseExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& CaseExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.xpr)
  return _internal_xpr();
}
inline void CaseExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseExpr.xpr)
}
inline ::pg_query::Node* CaseExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CaseExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.CaseExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* CaseExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.CaseExpr.xpr)
  return _internal_mutable_xpr();
}
inline void CaseExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CaseExpr.xpr)
}

// uint32 casetype = 2 [json_name = "casetype"];
inline void CaseExpr::clear_casetype() {
  casetype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CaseExpr::_internal_casetype() const {
  return casetype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CaseExpr::casetype() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.casetype)
  return _internal_casetype();
}
inline void CaseExpr::_internal_set_casetype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  casetype_ = value;
}
inline void CaseExpr::set_casetype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_casetype(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseExpr.casetype)
}

// uint32 casecollid = 3 [json_name = "casecollid"];
inline void CaseExpr::clear_casecollid() {
  casecollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CaseExpr::_internal_casecollid() const {
  return casecollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CaseExpr::casecollid() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.casecollid)
  return _internal_casecollid();
}
inline void CaseExpr::_internal_set_casecollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  casecollid_ = value;
}
inline void CaseExpr::set_casecollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_casecollid(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseExpr.casecollid)
}

// .pg_query.Node arg = 4 [json_name = "arg"];
inline bool CaseExpr::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool CaseExpr::has_arg() const {
  return _internal_has_arg();
}
inline void CaseExpr::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& CaseExpr::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseExpr::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.arg)
  return _internal_arg();
}
inline void CaseExpr::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseExpr.arg)
}
inline ::pg_query::Node* CaseExpr::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CaseExpr::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.CaseExpr.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseExpr::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* CaseExpr::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.CaseExpr.arg)
  return _internal_mutable_arg();
}
inline void CaseExpr::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CaseExpr.arg)
}

// repeated .pg_query.Node args = 5 [json_name = "args"];
inline int CaseExpr::_internal_args_size() const {
  return args_.size();
}
inline int CaseExpr::args_size() const {
  return _internal_args_size();
}
inline void CaseExpr::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* CaseExpr::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CaseExpr.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CaseExpr::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CaseExpr.args)
  return &args_;
}
inline const ::pg_query::Node& CaseExpr::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& CaseExpr::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.args)
  return _internal_args(index);
}
inline ::pg_query::Node* CaseExpr::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* CaseExpr::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.CaseExpr.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CaseExpr::args() const {
  // @@protoc_insertion_point(field_list:pg_query.CaseExpr.args)
  return args_;
}

// .pg_query.Node defresult = 6 [json_name = "defresult"];
inline bool CaseExpr::_internal_has_defresult() const {
  return this != internal_default_instance() && defresult_ != nullptr;
}
inline bool CaseExpr::has_defresult() const {
  return _internal_has_defresult();
}
inline void CaseExpr::clear_defresult() {
  if (GetArena() == nullptr && defresult_ != nullptr) {
    delete defresult_;
  }
  defresult_ = nullptr;
}
inline const ::pg_query::Node& CaseExpr::_internal_defresult() const {
  const ::pg_query::Node* p = defresult_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseExpr::defresult() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.defresult)
  return _internal_defresult();
}
inline void CaseExpr::unsafe_arena_set_allocated_defresult(
    ::pg_query::Node* defresult) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(defresult_);
  }
  defresult_ = defresult;
  if (defresult) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseExpr.defresult)
}
inline ::pg_query::Node* CaseExpr::release_defresult() {
  
  ::pg_query::Node* temp = defresult_;
  defresult_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CaseExpr::unsafe_arena_release_defresult() {
  // @@protoc_insertion_point(field_release:pg_query.CaseExpr.defresult)
  
  ::pg_query::Node* temp = defresult_;
  defresult_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseExpr::_internal_mutable_defresult() {
  
  if (defresult_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    defresult_ = p;
  }
  return defresult_;
}
inline ::pg_query::Node* CaseExpr::mutable_defresult() {
  // @@protoc_insertion_point(field_mutable:pg_query.CaseExpr.defresult)
  return _internal_mutable_defresult();
}
inline void CaseExpr::set_allocated_defresult(::pg_query::Node* defresult) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete defresult_;
  }
  if (defresult) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(defresult);
    if (message_arena != submessage_arena) {
      defresult = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, defresult, submessage_arena);
    }
    
  } else {
    
  }
  defresult_ = defresult;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CaseExpr.defresult)
}

// int32 location = 7 [json_name = "location"];
inline void CaseExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CaseExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CaseExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.location)
  return _internal_location();
}
inline void CaseExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void CaseExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseExpr.location)
}

// -------------------------------------------------------------------

// CaseWhen

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CaseWhen::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool CaseWhen::has_xpr() const {
  return _internal_has_xpr();
}
inline void CaseWhen::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& CaseWhen::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseWhen::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseWhen.xpr)
  return _internal_xpr();
}
inline void CaseWhen::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseWhen.xpr)
}
inline ::pg_query::Node* CaseWhen::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CaseWhen::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.CaseWhen.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseWhen::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* CaseWhen::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.CaseWhen.xpr)
  return _internal_mutable_xpr();
}
inline void CaseWhen::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CaseWhen.xpr)
}

// .pg_query.Node expr = 2 [json_name = "expr"];
inline bool CaseWhen::_internal_has_expr() const {
  return this != internal_default_instance() && expr_ != nullptr;
}
inline bool CaseWhen::has_expr() const {
  return _internal_has_expr();
}
inline void CaseWhen::clear_expr() {
  if (GetArena() == nullptr && expr_ != nullptr) {
    delete expr_;
  }
  expr_ = nullptr;
}
inline const ::pg_query::Node& CaseWhen::_internal_expr() const {
  const ::pg_query::Node* p = expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseWhen::expr() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseWhen.expr)
  return _internal_expr();
}
inline void CaseWhen::unsafe_arena_set_allocated_expr(
    ::pg_query::Node* expr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expr_);
  }
  expr_ = expr;
  if (expr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseWhen.expr)
}
inline ::pg_query::Node* CaseWhen::release_expr() {
  
  ::pg_query::Node* temp = expr_;
  expr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CaseWhen::unsafe_arena_release_expr() {
  // @@protoc_insertion_point(field_release:pg_query.CaseWhen.expr)
  
  ::pg_query::Node* temp = expr_;
  expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseWhen::_internal_mutable_expr() {
  
  if (expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    expr_ = p;
  }
  return expr_;
}
inline ::pg_query::Node* CaseWhen::mutable_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.CaseWhen.expr)
  return _internal_mutable_expr();
}
inline void CaseWhen::set_allocated_expr(::pg_query::Node* expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete expr_;
  }
  if (expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expr);
    if (message_arena != submessage_arena) {
      expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, expr, submessage_arena);
    }
    
  } else {
    
  }
  expr_ = expr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CaseWhen.expr)
}

// .pg_query.Node result = 3 [json_name = "result"];
inline bool CaseWhen::_internal_has_result() const {
  return this != internal_default_instance() && result_ != nullptr;
}
inline bool CaseWhen::has_result() const {
  return _internal_has_result();
}
inline void CaseWhen::clear_result() {
  if (GetArena() == nullptr && result_ != nullptr) {
    delete result_;
  }
  result_ = nullptr;
}
inline const ::pg_query::Node& CaseWhen::_internal_result() const {
  const ::pg_query::Node* p = result_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseWhen::result() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseWhen.result)
  return _internal_result();
}
inline void CaseWhen::unsafe_arena_set_allocated_result(
    ::pg_query::Node* result) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(result_);
  }
  result_ = result;
  if (result) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseWhen.result)
}
inline ::pg_query::Node* CaseWhen::release_result() {
  
  ::pg_query::Node* temp = result_;
  result_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CaseWhen::unsafe_arena_release_result() {
  // @@protoc_insertion_point(field_release:pg_query.CaseWhen.result)
  
  ::pg_query::Node* temp = result_;
  result_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseWhen::_internal_mutable_result() {
  
  if (result_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    result_ = p;
  }
  return result_;
}
inline ::pg_query::Node* CaseWhen::mutable_result() {
  // @@protoc_insertion_point(field_mutable:pg_query.CaseWhen.result)
  return _internal_mutable_result();
}
inline void CaseWhen::set_allocated_result(::pg_query::Node* result) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete result_;
  }
  if (result) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(result);
    if (message_arena != submessage_arena) {
      result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, result, submessage_arena);
    }
    
  } else {
    
  }
  result_ = result;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CaseWhen.result)
}

// int32 location = 4 [json_name = "location"];
inline void CaseWhen::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CaseWhen::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CaseWhen::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseWhen.location)
  return _internal_location();
}
inline void CaseWhen::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void CaseWhen::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseWhen.location)
}

// -------------------------------------------------------------------

// CaseTestExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CaseTestExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool CaseTestExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void CaseTestExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& CaseTestExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseTestExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseTestExpr.xpr)
  return _internal_xpr();
}
inline void CaseTestExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseTestExpr.xpr)
}
inline ::pg_query::Node* CaseTestExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CaseTestExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.CaseTestExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseTestExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* CaseTestExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.CaseTestExpr.xpr)
  return _internal_mutable_xpr();
}
inline void CaseTestExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CaseTestExpr.xpr)
}

// uint32 type_id = 2 [json_name = "typeId"];
inline void CaseTestExpr::clear_type_id() {
  type_id_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CaseTestExpr::_internal_type_id() const {
  return type_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CaseTestExpr::type_id() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseTestExpr.type_id)
  return _internal_type_id();
}
inline void CaseTestExpr::_internal_set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  type_id_ = value;
}
inline void CaseTestExpr::set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_type_id(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseTestExpr.type_id)
}

// int32 type_mod = 3 [json_name = "typeMod"];
inline void CaseTestExpr::clear_type_mod() {
  type_mod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CaseTestExpr::_internal_type_mod() const {
  return type_mod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CaseTestExpr::type_mod() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseTestExpr.type_mod)
  return _internal_type_mod();
}
inline void CaseTestExpr::_internal_set_type_mod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  type_mod_ = value;
}
inline void CaseTestExpr::set_type_mod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_type_mod(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseTestExpr.type_mod)
}

// uint32 collation = 4 [json_name = "collation"];
inline void CaseTestExpr::clear_collation() {
  collation_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CaseTestExpr::_internal_collation() const {
  return collation_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CaseTestExpr::collation() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseTestExpr.collation)
  return _internal_collation();
}
inline void CaseTestExpr::_internal_set_collation(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  collation_ = value;
}
inline void CaseTestExpr::set_collation(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_collation(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseTestExpr.collation)
}

// -------------------------------------------------------------------

// ArrayExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool ArrayExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool ArrayExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void ArrayExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& ArrayExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ArrayExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.xpr)
  return _internal_xpr();
}
inline void ArrayExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ArrayExpr.xpr)
}
inline ::pg_query::Node* ArrayExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* ArrayExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.ArrayExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ArrayExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* ArrayExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.ArrayExpr.xpr)
  return _internal_mutable_xpr();
}
inline void ArrayExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ArrayExpr.xpr)
}

// uint32 array_typeid = 2 [json_name = "array_typeid"];
inline void ArrayExpr::clear_array_typeid() {
  array_typeid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ArrayExpr::_internal_array_typeid() const {
  return array_typeid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ArrayExpr::array_typeid() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.array_typeid)
  return _internal_array_typeid();
}
inline void ArrayExpr::_internal_set_array_typeid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  array_typeid_ = value;
}
inline void ArrayExpr::set_array_typeid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_array_typeid(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.array_typeid)
}

// uint32 array_collid = 3 [json_name = "array_collid"];
inline void ArrayExpr::clear_array_collid() {
  array_collid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ArrayExpr::_internal_array_collid() const {
  return array_collid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ArrayExpr::array_collid() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.array_collid)
  return _internal_array_collid();
}
inline void ArrayExpr::_internal_set_array_collid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  array_collid_ = value;
}
inline void ArrayExpr::set_array_collid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_array_collid(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.array_collid)
}

// uint32 element_typeid = 4 [json_name = "element_typeid"];
inline void ArrayExpr::clear_element_typeid() {
  element_typeid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ArrayExpr::_internal_element_typeid() const {
  return element_typeid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ArrayExpr::element_typeid() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.element_typeid)
  return _internal_element_typeid();
}
inline void ArrayExpr::_internal_set_element_typeid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  element_typeid_ = value;
}
inline void ArrayExpr::set_element_typeid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_element_typeid(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.element_typeid)
}

// repeated .pg_query.Node elements = 5 [json_name = "elements"];
inline int ArrayExpr::_internal_elements_size() const {
  return elements_.size();
}
inline int ArrayExpr::elements_size() const {
  return _internal_elements_size();
}
inline void ArrayExpr::clear_elements() {
  elements_.Clear();
}
inline ::pg_query::Node* ArrayExpr::mutable_elements(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ArrayExpr.elements)
  return elements_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ArrayExpr::mutable_elements() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ArrayExpr.elements)
  return &elements_;
}
inline const ::pg_query::Node& ArrayExpr::_internal_elements(int index) const {
  return elements_.Get(index);
}
inline const ::pg_query::Node& ArrayExpr::elements(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.elements)
  return _internal_elements(index);
}
inline ::pg_query::Node* ArrayExpr::_internal_add_elements() {
  return elements_.Add();
}
inline ::pg_query::Node* ArrayExpr::add_elements() {
  // @@protoc_insertion_point(field_add:pg_query.ArrayExpr.elements)
  return _internal_add_elements();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ArrayExpr::elements() const {
  // @@protoc_insertion_point(field_list:pg_query.ArrayExpr.elements)
  return elements_;
}

// bool multidims = 6 [json_name = "multidims"];
inline void ArrayExpr::clear_multidims() {
  multidims_ = false;
}
inline bool ArrayExpr::_internal_multidims() const {
  return multidims_;
}
inline bool ArrayExpr::multidims() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.multidims)
  return _internal_multidims();
}
inline void ArrayExpr::_internal_set_multidims(bool value) {
  
  multidims_ = value;
}
inline void ArrayExpr::set_multidims(bool value) {
  _internal_set_multidims(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.multidims)
}

// int32 location = 7 [json_name = "location"];
inline void ArrayExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ArrayExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ArrayExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.location)
  return _internal_location();
}
inline void ArrayExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void ArrayExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.location)
}

// -------------------------------------------------------------------

// RowExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool RowExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool RowExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void RowExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& RowExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RowExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.RowExpr.xpr)
  return _internal_xpr();
}
inline void RowExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RowExpr.xpr)
}
inline ::pg_query::Node* RowExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RowExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.RowExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RowExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* RowExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.RowExpr.xpr)
  return _internal_mutable_xpr();
}
inline void RowExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RowExpr.xpr)
}

// repeated .pg_query.Node args = 2 [json_name = "args"];
inline int RowExpr::_internal_args_size() const {
  return args_.size();
}
inline int RowExpr::args_size() const {
  return _internal_args_size();
}
inline void RowExpr::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* RowExpr::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RowExpr.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RowExpr::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowExpr.args)
  return &args_;
}
inline const ::pg_query::Node& RowExpr::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& RowExpr::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RowExpr.args)
  return _internal_args(index);
}
inline ::pg_query::Node* RowExpr::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* RowExpr::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.RowExpr.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RowExpr::args() const {
  // @@protoc_insertion_point(field_list:pg_query.RowExpr.args)
  return args_;
}

// uint32 row_typeid = 3 [json_name = "row_typeid"];
inline void RowExpr::clear_row_typeid() {
  row_typeid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RowExpr::_internal_row_typeid() const {
  return row_typeid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RowExpr::row_typeid() const {
  // @@protoc_insertion_point(field_get:pg_query.RowExpr.row_typeid)
  return _internal_row_typeid();
}
inline void RowExpr::_internal_set_row_typeid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  row_typeid_ = value;
}
inline void RowExpr::set_row_typeid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_row_typeid(value);
  // @@protoc_insertion_point(field_set:pg_query.RowExpr.row_typeid)
}

// .pg_query.CoercionForm row_format = 4 [json_name = "row_format"];
inline void RowExpr::clear_row_format() {
  row_format_ = 0;
}
inline ::pg_query::CoercionForm RowExpr::_internal_row_format() const {
  return static_cast< ::pg_query::CoercionForm >(row_format_);
}
inline ::pg_query::CoercionForm RowExpr::row_format() const {
  // @@protoc_insertion_point(field_get:pg_query.RowExpr.row_format)
  return _internal_row_format();
}
inline void RowExpr::_internal_set_row_format(::pg_query::CoercionForm value) {
  
  row_format_ = value;
}
inline void RowExpr::set_row_format(::pg_query::CoercionForm value) {
  _internal_set_row_format(value);
  // @@protoc_insertion_point(field_set:pg_query.RowExpr.row_format)
}

// repeated .pg_query.Node colnames = 5 [json_name = "colnames"];
inline int RowExpr::_internal_colnames_size() const {
  return colnames_.size();
}
inline int RowExpr::colnames_size() const {
  return _internal_colnames_size();
}
inline void RowExpr::clear_colnames() {
  colnames_.Clear();
}
inline ::pg_query::Node* RowExpr::mutable_colnames(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RowExpr.colnames)
  return colnames_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RowExpr::mutable_colnames() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowExpr.colnames)
  return &colnames_;
}
inline const ::pg_query::Node& RowExpr::_internal_colnames(int index) const {
  return colnames_.Get(index);
}
inline const ::pg_query::Node& RowExpr::colnames(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RowExpr.colnames)
  return _internal_colnames(index);
}
inline ::pg_query::Node* RowExpr::_internal_add_colnames() {
  return colnames_.Add();
}
inline ::pg_query::Node* RowExpr::add_colnames() {
  // @@protoc_insertion_point(field_add:pg_query.RowExpr.colnames)
  return _internal_add_colnames();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RowExpr::colnames() const {
  // @@protoc_insertion_point(field_list:pg_query.RowExpr.colnames)
  return colnames_;
}

// int32 location = 6 [json_name = "location"];
inline void RowExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RowExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RowExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RowExpr.location)
  return _internal_location();
}
inline void RowExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void RowExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RowExpr.location)
}

// -------------------------------------------------------------------

// RowCompareExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool RowCompareExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool RowCompareExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void RowCompareExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& RowCompareExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RowCompareExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.xpr)
  return _internal_xpr();
}
inline void RowCompareExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RowCompareExpr.xpr)
}
inline ::pg_query::Node* RowCompareExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RowCompareExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.RowCompareExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RowCompareExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* RowCompareExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.xpr)
  return _internal_mutable_xpr();
}
inline void RowCompareExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RowCompareExpr.xpr)
}

// .pg_query.RowCompareType rctype = 2 [json_name = "rctype"];
inline void RowCompareExpr::clear_rctype() {
  rctype_ = 0;
}
inline ::pg_query::RowCompareType RowCompareExpr::_internal_rctype() const {
  return static_cast< ::pg_query::RowCompareType >(rctype_);
}
inline ::pg_query::RowCompareType RowCompareExpr::rctype() const {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.rctype)
  return _internal_rctype();
}
inline void RowCompareExpr::_internal_set_rctype(::pg_query::RowCompareType value) {
  
  rctype_ = value;
}
inline void RowCompareExpr::set_rctype(::pg_query::RowCompareType value) {
  _internal_set_rctype(value);
  // @@protoc_insertion_point(field_set:pg_query.RowCompareExpr.rctype)
}

// repeated .pg_query.Node opnos = 3 [json_name = "opnos"];
inline int RowCompareExpr::_internal_opnos_size() const {
  return opnos_.size();
}
inline int RowCompareExpr::opnos_size() const {
  return _internal_opnos_size();
}
inline void RowCompareExpr::clear_opnos() {
  opnos_.Clear();
}
inline ::pg_query::Node* RowCompareExpr::mutable_opnos(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.opnos)
  return opnos_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RowCompareExpr::mutable_opnos() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.opnos)
  return &opnos_;
}
inline const ::pg_query::Node& RowCompareExpr::_internal_opnos(int index) const {
  return opnos_.Get(index);
}
inline const ::pg_query::Node& RowCompareExpr::opnos(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.opnos)
  return _internal_opnos(index);
}
inline ::pg_query::Node* RowCompareExpr::_internal_add_opnos() {
  return opnos_.Add();
}
inline ::pg_query::Node* RowCompareExpr::add_opnos() {
  // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.opnos)
  return _internal_add_opnos();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RowCompareExpr::opnos() const {
  // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.opnos)
  return opnos_;
}

// repeated .pg_query.Node opfamilies = 4 [json_name = "opfamilies"];
inline int RowCompareExpr::_internal_opfamilies_size() const {
  return opfamilies_.size();
}
inline int RowCompareExpr::opfamilies_size() const {
  return _internal_opfamilies_size();
}
inline void RowCompareExpr::clear_opfamilies() {
  opfamilies_.Clear();
}
inline ::pg_query::Node* RowCompareExpr::mutable_opfamilies(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.opfamilies)
  return opfamilies_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RowCompareExpr::mutable_opfamilies() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.opfamilies)
  return &opfamilies_;
}
inline const ::pg_query::Node& RowCompareExpr::_internal_opfamilies(int index) const {
  return opfamilies_.Get(index);
}
inline const ::pg_query::Node& RowCompareExpr::opfamilies(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.opfamilies)
  return _internal_opfamilies(index);
}
inline ::pg_query::Node* RowCompareExpr::_internal_add_opfamilies() {
  return opfamilies_.Add();
}
inline ::pg_query::Node* RowCompareExpr::add_opfamilies() {
  // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.opfamilies)
  return _internal_add_opfamilies();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RowCompareExpr::opfamilies() const {
  // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.opfamilies)
  return opfamilies_;
}

// repeated .pg_query.Node inputcollids = 5 [json_name = "inputcollids"];
inline int RowCompareExpr::_internal_inputcollids_size() const {
  return inputcollids_.size();
}
inline int RowCompareExpr::inputcollids_size() const {
  return _internal_inputcollids_size();
}
inline void RowCompareExpr::clear_inputcollids() {
  inputcollids_.Clear();
}
inline ::pg_query::Node* RowCompareExpr::mutable_inputcollids(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.inputcollids)
  return inputcollids_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RowCompareExpr::mutable_inputcollids() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.inputcollids)
  return &inputcollids_;
}
inline const ::pg_query::Node& RowCompareExpr::_internal_inputcollids(int index) const {
  return inputcollids_.Get(index);
}
inline const ::pg_query::Node& RowCompareExpr::inputcollids(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.inputcollids)
  return _internal_inputcollids(index);
}
inline ::pg_query::Node* RowCompareExpr::_internal_add_inputcollids() {
  return inputcollids_.Add();
}
inline ::pg_query::Node* RowCompareExpr::add_inputcollids() {
  // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.inputcollids)
  return _internal_add_inputcollids();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RowCompareExpr::inputcollids() const {
  // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.inputcollids)
  return inputcollids_;
}

// repeated .pg_query.Node largs = 6 [json_name = "largs"];
inline int RowCompareExpr::_internal_largs_size() const {
  return largs_.size();
}
inline int RowCompareExpr::largs_size() const {
  return _internal_largs_size();
}
inline void RowCompareExpr::clear_largs() {
  largs_.Clear();
}
inline ::pg_query::Node* RowCompareExpr::mutable_largs(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.largs)
  return largs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RowCompareExpr::mutable_largs() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.largs)
  return &largs_;
}
inline const ::pg_query::Node& RowCompareExpr::_internal_largs(int index) const {
  return largs_.Get(index);
}
inline const ::pg_query::Node& RowCompareExpr::largs(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.largs)
  return _internal_largs(index);
}
inline ::pg_query::Node* RowCompareExpr::_internal_add_largs() {
  return largs_.Add();
}
inline ::pg_query::Node* RowCompareExpr::add_largs() {
  // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.largs)
  return _internal_add_largs();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RowCompareExpr::largs() const {
  // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.largs)
  return largs_;
}

// repeated .pg_query.Node rargs = 7 [json_name = "rargs"];
inline int RowCompareExpr::_internal_rargs_size() const {
  return rargs_.size();
}
inline int RowCompareExpr::rargs_size() const {
  return _internal_rargs_size();
}
inline void RowCompareExpr::clear_rargs() {
  rargs_.Clear();
}
inline ::pg_query::Node* RowCompareExpr::mutable_rargs(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.rargs)
  return rargs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RowCompareExpr::mutable_rargs() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.rargs)
  return &rargs_;
}
inline const ::pg_query::Node& RowCompareExpr::_internal_rargs(int index) const {
  return rargs_.Get(index);
}
inline const ::pg_query::Node& RowCompareExpr::rargs(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.rargs)
  return _internal_rargs(index);
}
inline ::pg_query::Node* RowCompareExpr::_internal_add_rargs() {
  return rargs_.Add();
}
inline ::pg_query::Node* RowCompareExpr::add_rargs() {
  // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.rargs)
  return _internal_add_rargs();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RowCompareExpr::rargs() const {
  // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.rargs)
  return rargs_;
}

// -------------------------------------------------------------------

// CoalesceExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CoalesceExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool CoalesceExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void CoalesceExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& CoalesceExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CoalesceExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.xpr)
  return _internal_xpr();
}
inline void CoalesceExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoalesceExpr.xpr)
}
inline ::pg_query::Node* CoalesceExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CoalesceExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.CoalesceExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CoalesceExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* CoalesceExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.CoalesceExpr.xpr)
  return _internal_mutable_xpr();
}
inline void CoalesceExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CoalesceExpr.xpr)
}

// uint32 coalescetype = 2 [json_name = "coalescetype"];
inline void CoalesceExpr::clear_coalescetype() {
  coalescetype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoalesceExpr::_internal_coalescetype() const {
  return coalescetype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoalesceExpr::coalescetype() const {
  // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.coalescetype)
  return _internal_coalescetype();
}
inline void CoalesceExpr::_internal_set_coalescetype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  coalescetype_ = value;
}
inline void CoalesceExpr::set_coalescetype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_coalescetype(value);
  // @@protoc_insertion_point(field_set:pg_query.CoalesceExpr.coalescetype)
}

// uint32 coalescecollid = 3 [json_name = "coalescecollid"];
inline void CoalesceExpr::clear_coalescecollid() {
  coalescecollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoalesceExpr::_internal_coalescecollid() const {
  return coalescecollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoalesceExpr::coalescecollid() const {
  // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.coalescecollid)
  return _internal_coalescecollid();
}
inline void CoalesceExpr::_internal_set_coalescecollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  coalescecollid_ = value;
}
inline void CoalesceExpr::set_coalescecollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_coalescecollid(value);
  // @@protoc_insertion_point(field_set:pg_query.CoalesceExpr.coalescecollid)
}

// repeated .pg_query.Node args = 4 [json_name = "args"];
inline int CoalesceExpr::_internal_args_size() const {
  return args_.size();
}
inline int CoalesceExpr::args_size() const {
  return _internal_args_size();
}
inline void CoalesceExpr::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* CoalesceExpr::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CoalesceExpr.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CoalesceExpr::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CoalesceExpr.args)
  return &args_;
}
inline const ::pg_query::Node& CoalesceExpr::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& CoalesceExpr::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.args)
  return _internal_args(index);
}
inline ::pg_query::Node* CoalesceExpr::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* CoalesceExpr::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.CoalesceExpr.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CoalesceExpr::args() const {
  // @@protoc_insertion_point(field_list:pg_query.CoalesceExpr.args)
  return args_;
}

// int32 location = 5 [json_name = "location"];
inline void CoalesceExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CoalesceExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CoalesceExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.location)
  return _internal_location();
}
inline void CoalesceExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void CoalesceExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CoalesceExpr.location)
}

// -------------------------------------------------------------------

// MinMaxExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool MinMaxExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool MinMaxExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void MinMaxExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& MinMaxExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& MinMaxExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.xpr)
  return _internal_xpr();
}
inline void MinMaxExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MinMaxExpr.xpr)
}
inline ::pg_query::Node* MinMaxExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* MinMaxExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.MinMaxExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* MinMaxExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* MinMaxExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.MinMaxExpr.xpr)
  return _internal_mutable_xpr();
}
inline void MinMaxExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.MinMaxExpr.xpr)
}

// uint32 minmaxtype = 2 [json_name = "minmaxtype"];
inline void MinMaxExpr::clear_minmaxtype() {
  minmaxtype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 MinMaxExpr::_internal_minmaxtype() const {
  return minmaxtype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 MinMaxExpr::minmaxtype() const {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.minmaxtype)
  return _internal_minmaxtype();
}
inline void MinMaxExpr::_internal_set_minmaxtype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  minmaxtype_ = value;
}
inline void MinMaxExpr::set_minmaxtype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_minmaxtype(value);
  // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.minmaxtype)
}

// uint32 minmaxcollid = 3 [json_name = "minmaxcollid"];
inline void MinMaxExpr::clear_minmaxcollid() {
  minmaxcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 MinMaxExpr::_internal_minmaxcollid() const {
  return minmaxcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 MinMaxExpr::minmaxcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.minmaxcollid)
  return _internal_minmaxcollid();
}
inline void MinMaxExpr::_internal_set_minmaxcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  minmaxcollid_ = value;
}
inline void MinMaxExpr::set_minmaxcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_minmaxcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.minmaxcollid)
}

// uint32 inputcollid = 4 [json_name = "inputcollid"];
inline void MinMaxExpr::clear_inputcollid() {
  inputcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 MinMaxExpr::_internal_inputcollid() const {
  return inputcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 MinMaxExpr::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.inputcollid)
  return _internal_inputcollid();
}
inline void MinMaxExpr::_internal_set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  inputcollid_ = value;
}
inline void MinMaxExpr::set_inputcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.inputcollid)
}

// .pg_query.MinMaxOp op = 5 [json_name = "op"];
inline void MinMaxExpr::clear_op() {
  op_ = 0;
}
inline ::pg_query::MinMaxOp MinMaxExpr::_internal_op() const {
  return static_cast< ::pg_query::MinMaxOp >(op_);
}
inline ::pg_query::MinMaxOp MinMaxExpr::op() const {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.op)
  return _internal_op();
}
inline void MinMaxExpr::_internal_set_op(::pg_query::MinMaxOp value) {
  
  op_ = value;
}
inline void MinMaxExpr::set_op(::pg_query::MinMaxOp value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.op)
}

// repeated .pg_query.Node args = 6 [json_name = "args"];
inline int MinMaxExpr::_internal_args_size() const {
  return args_.size();
}
inline int MinMaxExpr::args_size() const {
  return _internal_args_size();
}
inline void MinMaxExpr::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* MinMaxExpr::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.MinMaxExpr.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
MinMaxExpr::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.MinMaxExpr.args)
  return &args_;
}
inline const ::pg_query::Node& MinMaxExpr::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& MinMaxExpr::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.args)
  return _internal_args(index);
}
inline ::pg_query::Node* MinMaxExpr::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* MinMaxExpr::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.MinMaxExpr.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
MinMaxExpr::args() const {
  // @@protoc_insertion_point(field_list:pg_query.MinMaxExpr.args)
  return args_;
}

// int32 location = 7 [json_name = "location"];
inline void MinMaxExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 MinMaxExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 MinMaxExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.location)
  return _internal_location();
}
inline void MinMaxExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void MinMaxExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.location)
}

// -------------------------------------------------------------------

// SQLValueFunction

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool SQLValueFunction::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool SQLValueFunction::has_xpr() const {
  return _internal_has_xpr();
}
inline void SQLValueFunction::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& SQLValueFunction::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SQLValueFunction::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.xpr)
  return _internal_xpr();
}
inline void SQLValueFunction::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SQLValueFunction.xpr)
}
inline ::pg_query::Node* SQLValueFunction::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SQLValueFunction::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.SQLValueFunction.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SQLValueFunction::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* SQLValueFunction::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.SQLValueFunction.xpr)
  return _internal_mutable_xpr();
}
inline void SQLValueFunction::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SQLValueFunction.xpr)
}

// .pg_query.SQLValueFunctionOp op = 2 [json_name = "op"];
inline void SQLValueFunction::clear_op() {
  op_ = 0;
}
inline ::pg_query::SQLValueFunctionOp SQLValueFunction::_internal_op() const {
  return static_cast< ::pg_query::SQLValueFunctionOp >(op_);
}
inline ::pg_query::SQLValueFunctionOp SQLValueFunction::op() const {
  // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.op)
  return _internal_op();
}
inline void SQLValueFunction::_internal_set_op(::pg_query::SQLValueFunctionOp value) {
  
  op_ = value;
}
inline void SQLValueFunction::set_op(::pg_query::SQLValueFunctionOp value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:pg_query.SQLValueFunction.op)
}

// uint32 type = 3 [json_name = "type"];
inline void SQLValueFunction::clear_type() {
  type_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SQLValueFunction::_internal_type() const {
  return type_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SQLValueFunction::type() const {
  // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.type)
  return _internal_type();
}
inline void SQLValueFunction::_internal_set_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  type_ = value;
}
inline void SQLValueFunction::set_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:pg_query.SQLValueFunction.type)
}

// int32 typmod = 4 [json_name = "typmod"];
inline void SQLValueFunction::clear_typmod() {
  typmod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SQLValueFunction::_internal_typmod() const {
  return typmod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SQLValueFunction::typmod() const {
  // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.typmod)
  return _internal_typmod();
}
inline void SQLValueFunction::_internal_set_typmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  typmod_ = value;
}
inline void SQLValueFunction::set_typmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_typmod(value);
  // @@protoc_insertion_point(field_set:pg_query.SQLValueFunction.typmod)
}

// int32 location = 5 [json_name = "location"];
inline void SQLValueFunction::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SQLValueFunction::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SQLValueFunction::location() const {
  // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.location)
  return _internal_location();
}
inline void SQLValueFunction::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void SQLValueFunction::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.SQLValueFunction.location)
}

// -------------------------------------------------------------------

// XmlExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool XmlExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool XmlExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void XmlExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& XmlExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& XmlExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.xpr)
  return _internal_xpr();
}
inline void XmlExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.XmlExpr.xpr)
}
inline ::pg_query::Node* XmlExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* XmlExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.XmlExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* XmlExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* XmlExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.XmlExpr.xpr)
  return _internal_mutable_xpr();
}
inline void XmlExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.XmlExpr.xpr)
}

// .pg_query.XmlExprOp op = 2 [json_name = "op"];
inline void XmlExpr::clear_op() {
  op_ = 0;
}
inline ::pg_query::XmlExprOp XmlExpr::_internal_op() const {
  return static_cast< ::pg_query::XmlExprOp >(op_);
}
inline ::pg_query::XmlExprOp XmlExpr::op() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.op)
  return _internal_op();
}
inline void XmlExpr::_internal_set_op(::pg_query::XmlExprOp value) {
  
  op_ = value;
}
inline void XmlExpr::set_op(::pg_query::XmlExprOp value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlExpr.op)
}

// string name = 3 [json_name = "name"];
inline void XmlExpr::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& XmlExpr::name() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.name)
  return _internal_name();
}
inline void XmlExpr::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlExpr.name)
}
inline std::string* XmlExpr::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.XmlExpr.name)
  return _internal_mutable_name();
}
inline const std::string& XmlExpr::_internal_name() const {
  return name_.Get();
}
inline void XmlExpr::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void XmlExpr::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.XmlExpr.name)
}
inline void XmlExpr::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.XmlExpr.name)
}
inline void XmlExpr::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.XmlExpr.name)
}
inline std::string* XmlExpr::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* XmlExpr::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.XmlExpr.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void XmlExpr::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.XmlExpr.name)
}

// repeated .pg_query.Node named_args = 4 [json_name = "named_args"];
inline int XmlExpr::_internal_named_args_size() const {
  return named_args_.size();
}
inline int XmlExpr::named_args_size() const {
  return _internal_named_args_size();
}
inline void XmlExpr::clear_named_args() {
  named_args_.Clear();
}
inline ::pg_query::Node* XmlExpr::mutable_named_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.XmlExpr.named_args)
  return named_args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
XmlExpr::mutable_named_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.XmlExpr.named_args)
  return &named_args_;
}
inline const ::pg_query::Node& XmlExpr::_internal_named_args(int index) const {
  return named_args_.Get(index);
}
inline const ::pg_query::Node& XmlExpr::named_args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.named_args)
  return _internal_named_args(index);
}
inline ::pg_query::Node* XmlExpr::_internal_add_named_args() {
  return named_args_.Add();
}
inline ::pg_query::Node* XmlExpr::add_named_args() {
  // @@protoc_insertion_point(field_add:pg_query.XmlExpr.named_args)
  return _internal_add_named_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
XmlExpr::named_args() const {
  // @@protoc_insertion_point(field_list:pg_query.XmlExpr.named_args)
  return named_args_;
}

// repeated .pg_query.Node arg_names = 5 [json_name = "arg_names"];
inline int XmlExpr::_internal_arg_names_size() const {
  return arg_names_.size();
}
inline int XmlExpr::arg_names_size() const {
  return _internal_arg_names_size();
}
inline void XmlExpr::clear_arg_names() {
  arg_names_.Clear();
}
inline ::pg_query::Node* XmlExpr::mutable_arg_names(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.XmlExpr.arg_names)
  return arg_names_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
XmlExpr::mutable_arg_names() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.XmlExpr.arg_names)
  return &arg_names_;
}
inline const ::pg_query::Node& XmlExpr::_internal_arg_names(int index) const {
  return arg_names_.Get(index);
}
inline const ::pg_query::Node& XmlExpr::arg_names(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.arg_names)
  return _internal_arg_names(index);
}
inline ::pg_query::Node* XmlExpr::_internal_add_arg_names() {
  return arg_names_.Add();
}
inline ::pg_query::Node* XmlExpr::add_arg_names() {
  // @@protoc_insertion_point(field_add:pg_query.XmlExpr.arg_names)
  return _internal_add_arg_names();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
XmlExpr::arg_names() const {
  // @@protoc_insertion_point(field_list:pg_query.XmlExpr.arg_names)
  return arg_names_;
}

// repeated .pg_query.Node args = 6 [json_name = "args"];
inline int XmlExpr::_internal_args_size() const {
  return args_.size();
}
inline int XmlExpr::args_size() const {
  return _internal_args_size();
}
inline void XmlExpr::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* XmlExpr::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.XmlExpr.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
XmlExpr::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.XmlExpr.args)
  return &args_;
}
inline const ::pg_query::Node& XmlExpr::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& XmlExpr::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.args)
  return _internal_args(index);
}
inline ::pg_query::Node* XmlExpr::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* XmlExpr::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.XmlExpr.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
XmlExpr::args() const {
  // @@protoc_insertion_point(field_list:pg_query.XmlExpr.args)
  return args_;
}

// .pg_query.XmlOptionType xmloption = 7 [json_name = "xmloption"];
inline void XmlExpr::clear_xmloption() {
  xmloption_ = 0;
}
inline ::pg_query::XmlOptionType XmlExpr::_internal_xmloption() const {
  return static_cast< ::pg_query::XmlOptionType >(xmloption_);
}
inline ::pg_query::XmlOptionType XmlExpr::xmloption() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.xmloption)
  return _internal_xmloption();
}
inline void XmlExpr::_internal_set_xmloption(::pg_query::XmlOptionType value) {
  
  xmloption_ = value;
}
inline void XmlExpr::set_xmloption(::pg_query::XmlOptionType value) {
  _internal_set_xmloption(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlExpr.xmloption)
}

// uint32 type = 8 [json_name = "type"];
inline void XmlExpr::clear_type() {
  type_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 XmlExpr::_internal_type() const {
  return type_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 XmlExpr::type() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.type)
  return _internal_type();
}
inline void XmlExpr::_internal_set_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  type_ = value;
}
inline void XmlExpr::set_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlExpr.type)
}

// int32 typmod = 9 [json_name = "typmod"];
inline void XmlExpr::clear_typmod() {
  typmod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 XmlExpr::_internal_typmod() const {
  return typmod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 XmlExpr::typmod() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.typmod)
  return _internal_typmod();
}
inline void XmlExpr::_internal_set_typmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  typmod_ = value;
}
inline void XmlExpr::set_typmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_typmod(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlExpr.typmod)
}

// int32 location = 10 [json_name = "location"];
inline void XmlExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 XmlExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 XmlExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.location)
  return _internal_location();
}
inline void XmlExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void XmlExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlExpr.location)
}

// -------------------------------------------------------------------

// NullTest

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool NullTest::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool NullTest::has_xpr() const {
  return _internal_has_xpr();
}
inline void NullTest::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& NullTest::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& NullTest::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.NullTest.xpr)
  return _internal_xpr();
}
inline void NullTest::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NullTest.xpr)
}
inline ::pg_query::Node* NullTest::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* NullTest::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.NullTest.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* NullTest::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* NullTest::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.NullTest.xpr)
  return _internal_mutable_xpr();
}
inline void NullTest::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.NullTest.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool NullTest::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool NullTest::has_arg() const {
  return _internal_has_arg();
}
inline void NullTest::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& NullTest::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& NullTest::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.NullTest.arg)
  return _internal_arg();
}
inline void NullTest::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NullTest.arg)
}
inline ::pg_query::Node* NullTest::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* NullTest::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.NullTest.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* NullTest::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* NullTest::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.NullTest.arg)
  return _internal_mutable_arg();
}
inline void NullTest::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.NullTest.arg)
}

// .pg_query.NullTestType nulltesttype = 3 [json_name = "nulltesttype"];
inline void NullTest::clear_nulltesttype() {
  nulltesttype_ = 0;
}
inline ::pg_query::NullTestType NullTest::_internal_nulltesttype() const {
  return static_cast< ::pg_query::NullTestType >(nulltesttype_);
}
inline ::pg_query::NullTestType NullTest::nulltesttype() const {
  // @@protoc_insertion_point(field_get:pg_query.NullTest.nulltesttype)
  return _internal_nulltesttype();
}
inline void NullTest::_internal_set_nulltesttype(::pg_query::NullTestType value) {
  
  nulltesttype_ = value;
}
inline void NullTest::set_nulltesttype(::pg_query::NullTestType value) {
  _internal_set_nulltesttype(value);
  // @@protoc_insertion_point(field_set:pg_query.NullTest.nulltesttype)
}

// bool argisrow = 4 [json_name = "argisrow"];
inline void NullTest::clear_argisrow() {
  argisrow_ = false;
}
inline bool NullTest::_internal_argisrow() const {
  return argisrow_;
}
inline bool NullTest::argisrow() const {
  // @@protoc_insertion_point(field_get:pg_query.NullTest.argisrow)
  return _internal_argisrow();
}
inline void NullTest::_internal_set_argisrow(bool value) {
  
  argisrow_ = value;
}
inline void NullTest::set_argisrow(bool value) {
  _internal_set_argisrow(value);
  // @@protoc_insertion_point(field_set:pg_query.NullTest.argisrow)
}

// int32 location = 5 [json_name = "location"];
inline void NullTest::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 NullTest::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 NullTest::location() const {
  // @@protoc_insertion_point(field_get:pg_query.NullTest.location)
  return _internal_location();
}
inline void NullTest::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void NullTest::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.NullTest.location)
}

// -------------------------------------------------------------------

// BooleanTest

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool BooleanTest::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool BooleanTest::has_xpr() const {
  return _internal_has_xpr();
}
inline void BooleanTest::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& BooleanTest::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& BooleanTest::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.BooleanTest.xpr)
  return _internal_xpr();
}
inline void BooleanTest::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.BooleanTest.xpr)
}
inline ::pg_query::Node* BooleanTest::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* BooleanTest::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.BooleanTest.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* BooleanTest::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* BooleanTest::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.BooleanTest.xpr)
  return _internal_mutable_xpr();
}
inline void BooleanTest::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.BooleanTest.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool BooleanTest::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool BooleanTest::has_arg() const {
  return _internal_has_arg();
}
inline void BooleanTest::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& BooleanTest::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& BooleanTest::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.BooleanTest.arg)
  return _internal_arg();
}
inline void BooleanTest::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.BooleanTest.arg)
}
inline ::pg_query::Node* BooleanTest::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* BooleanTest::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.BooleanTest.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* BooleanTest::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* BooleanTest::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.BooleanTest.arg)
  return _internal_mutable_arg();
}
inline void BooleanTest::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.BooleanTest.arg)
}

// .pg_query.BoolTestType booltesttype = 3 [json_name = "booltesttype"];
inline void BooleanTest::clear_booltesttype() {
  booltesttype_ = 0;
}
inline ::pg_query::BoolTestType BooleanTest::_internal_booltesttype() const {
  return static_cast< ::pg_query::BoolTestType >(booltesttype_);
}
inline ::pg_query::BoolTestType BooleanTest::booltesttype() const {
  // @@protoc_insertion_point(field_get:pg_query.BooleanTest.booltesttype)
  return _internal_booltesttype();
}
inline void BooleanTest::_internal_set_booltesttype(::pg_query::BoolTestType value) {
  
  booltesttype_ = value;
}
inline void BooleanTest::set_booltesttype(::pg_query::BoolTestType value) {
  _internal_set_booltesttype(value);
  // @@protoc_insertion_point(field_set:pg_query.BooleanTest.booltesttype)
}

// int32 location = 4 [json_name = "location"];
inline void BooleanTest::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 BooleanTest::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 BooleanTest::location() const {
  // @@protoc_insertion_point(field_get:pg_query.BooleanTest.location)
  return _internal_location();
}
inline void BooleanTest::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void BooleanTest::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.BooleanTest.location)
}

// -------------------------------------------------------------------

// CoerceToDomain

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CoerceToDomain::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool CoerceToDomain::has_xpr() const {
  return _internal_has_xpr();
}
inline void CoerceToDomain::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& CoerceToDomain::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CoerceToDomain::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.xpr)
  return _internal_xpr();
}
inline void CoerceToDomain::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceToDomain.xpr)
}
inline ::pg_query::Node* CoerceToDomain::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CoerceToDomain::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.CoerceToDomain.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CoerceToDomain::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* CoerceToDomain::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.CoerceToDomain.xpr)
  return _internal_mutable_xpr();
}
inline void CoerceToDomain::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceToDomain.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool CoerceToDomain::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool CoerceToDomain::has_arg() const {
  return _internal_has_arg();
}
inline void CoerceToDomain::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& CoerceToDomain::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CoerceToDomain::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.arg)
  return _internal_arg();
}
inline void CoerceToDomain::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceToDomain.arg)
}
inline ::pg_query::Node* CoerceToDomain::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CoerceToDomain::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.CoerceToDomain.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CoerceToDomain::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* CoerceToDomain::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.CoerceToDomain.arg)
  return _internal_mutable_arg();
}
inline void CoerceToDomain::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceToDomain.arg)
}

// uint32 resulttype = 3 [json_name = "resulttype"];
inline void CoerceToDomain::clear_resulttype() {
  resulttype_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoerceToDomain::_internal_resulttype() const {
  return resulttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoerceToDomain::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.resulttype)
  return _internal_resulttype();
}
inline void CoerceToDomain::_internal_set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  resulttype_ = value;
}
inline void CoerceToDomain::set_resulttype(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.resulttype)
}

// int32 resulttypmod = 4 [json_name = "resulttypmod"];
inline void CoerceToDomain::clear_resulttypmod() {
  resulttypmod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CoerceToDomain::_internal_resulttypmod() const {
  return resulttypmod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CoerceToDomain::resulttypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.resulttypmod)
  return _internal_resulttypmod();
}
inline void CoerceToDomain::_internal_set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  resulttypmod_ = value;
}
inline void CoerceToDomain::set_resulttypmod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_resulttypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.resulttypmod)
}

// uint32 resultcollid = 5 [json_name = "resultcollid"];
inline void CoerceToDomain::clear_resultcollid() {
  resultcollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoerceToDomain::_internal_resultcollid() const {
  return resultcollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoerceToDomain::resultcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.resultcollid)
  return _internal_resultcollid();
}
inline void CoerceToDomain::_internal_set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  resultcollid_ = value;
}
inline void CoerceToDomain::set_resultcollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resultcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.resultcollid)
}

// .pg_query.CoercionForm coercionformat = 6 [json_name = "coercionformat"];
inline void CoerceToDomain::clear_coercionformat() {
  coercionformat_ = 0;
}
inline ::pg_query::CoercionForm CoerceToDomain::_internal_coercionformat() const {
  return static_cast< ::pg_query::CoercionForm >(coercionformat_);
}
inline ::pg_query::CoercionForm CoerceToDomain::coercionformat() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.coercionformat)
  return _internal_coercionformat();
}
inline void CoerceToDomain::_internal_set_coercionformat(::pg_query::CoercionForm value) {
  
  coercionformat_ = value;
}
inline void CoerceToDomain::set_coercionformat(::pg_query::CoercionForm value) {
  _internal_set_coercionformat(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.coercionformat)
}

// int32 location = 7 [json_name = "location"];
inline void CoerceToDomain::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CoerceToDomain::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CoerceToDomain::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.location)
  return _internal_location();
}
inline void CoerceToDomain::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void CoerceToDomain::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.location)
}

// -------------------------------------------------------------------

// CoerceToDomainValue

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CoerceToDomainValue::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool CoerceToDomainValue::has_xpr() const {
  return _internal_has_xpr();
}
inline void CoerceToDomainValue::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& CoerceToDomainValue::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CoerceToDomainValue::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.xpr)
  return _internal_xpr();
}
inline void CoerceToDomainValue::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceToDomainValue.xpr)
}
inline ::pg_query::Node* CoerceToDomainValue::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CoerceToDomainValue::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.CoerceToDomainValue.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CoerceToDomainValue::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* CoerceToDomainValue::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.CoerceToDomainValue.xpr)
  return _internal_mutable_xpr();
}
inline void CoerceToDomainValue::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceToDomainValue.xpr)
}

// uint32 type_id = 2 [json_name = "typeId"];
inline void CoerceToDomainValue::clear_type_id() {
  type_id_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoerceToDomainValue::_internal_type_id() const {
  return type_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoerceToDomainValue::type_id() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.type_id)
  return _internal_type_id();
}
inline void CoerceToDomainValue::_internal_set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  type_id_ = value;
}
inline void CoerceToDomainValue::set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_type_id(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomainValue.type_id)
}

// int32 type_mod = 3 [json_name = "typeMod"];
inline void CoerceToDomainValue::clear_type_mod() {
  type_mod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CoerceToDomainValue::_internal_type_mod() const {
  return type_mod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CoerceToDomainValue::type_mod() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.type_mod)
  return _internal_type_mod();
}
inline void CoerceToDomainValue::_internal_set_type_mod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  type_mod_ = value;
}
inline void CoerceToDomainValue::set_type_mod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_type_mod(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomainValue.type_mod)
}

// uint32 collation = 4 [json_name = "collation"];
inline void CoerceToDomainValue::clear_collation() {
  collation_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoerceToDomainValue::_internal_collation() const {
  return collation_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CoerceToDomainValue::collation() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.collation)
  return _internal_collation();
}
inline void CoerceToDomainValue::_internal_set_collation(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  collation_ = value;
}
inline void CoerceToDomainValue::set_collation(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_collation(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomainValue.collation)
}

// int32 location = 5 [json_name = "location"];
inline void CoerceToDomainValue::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CoerceToDomainValue::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CoerceToDomainValue::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.location)
  return _internal_location();
}
inline void CoerceToDomainValue::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void CoerceToDomainValue::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomainValue.location)
}

// -------------------------------------------------------------------

// SetToDefault

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool SetToDefault::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool SetToDefault::has_xpr() const {
  return _internal_has_xpr();
}
inline void SetToDefault::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& SetToDefault::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SetToDefault::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.SetToDefault.xpr)
  return _internal_xpr();
}
inline void SetToDefault::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SetToDefault.xpr)
}
inline ::pg_query::Node* SetToDefault::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SetToDefault::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.SetToDefault.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SetToDefault::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* SetToDefault::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.SetToDefault.xpr)
  return _internal_mutable_xpr();
}
inline void SetToDefault::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SetToDefault.xpr)
}

// uint32 type_id = 2 [json_name = "typeId"];
inline void SetToDefault::clear_type_id() {
  type_id_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SetToDefault::_internal_type_id() const {
  return type_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SetToDefault::type_id() const {
  // @@protoc_insertion_point(field_get:pg_query.SetToDefault.type_id)
  return _internal_type_id();
}
inline void SetToDefault::_internal_set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  type_id_ = value;
}
inline void SetToDefault::set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_type_id(value);
  // @@protoc_insertion_point(field_set:pg_query.SetToDefault.type_id)
}

// int32 type_mod = 3 [json_name = "typeMod"];
inline void SetToDefault::clear_type_mod() {
  type_mod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SetToDefault::_internal_type_mod() const {
  return type_mod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SetToDefault::type_mod() const {
  // @@protoc_insertion_point(field_get:pg_query.SetToDefault.type_mod)
  return _internal_type_mod();
}
inline void SetToDefault::_internal_set_type_mod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  type_mod_ = value;
}
inline void SetToDefault::set_type_mod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_type_mod(value);
  // @@protoc_insertion_point(field_set:pg_query.SetToDefault.type_mod)
}

// uint32 collation = 4 [json_name = "collation"];
inline void SetToDefault::clear_collation() {
  collation_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SetToDefault::_internal_collation() const {
  return collation_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SetToDefault::collation() const {
  // @@protoc_insertion_point(field_get:pg_query.SetToDefault.collation)
  return _internal_collation();
}
inline void SetToDefault::_internal_set_collation(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  collation_ = value;
}
inline void SetToDefault::set_collation(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_collation(value);
  // @@protoc_insertion_point(field_set:pg_query.SetToDefault.collation)
}

// int32 location = 5 [json_name = "location"];
inline void SetToDefault::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SetToDefault::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SetToDefault::location() const {
  // @@protoc_insertion_point(field_get:pg_query.SetToDefault.location)
  return _internal_location();
}
inline void SetToDefault::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void SetToDefault::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.SetToDefault.location)
}

// -------------------------------------------------------------------

// CurrentOfExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CurrentOfExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool CurrentOfExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void CurrentOfExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& CurrentOfExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CurrentOfExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.CurrentOfExpr.xpr)
  return _internal_xpr();
}
inline void CurrentOfExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CurrentOfExpr.xpr)
}
inline ::pg_query::Node* CurrentOfExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CurrentOfExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.CurrentOfExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CurrentOfExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* CurrentOfExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.CurrentOfExpr.xpr)
  return _internal_mutable_xpr();
}
inline void CurrentOfExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CurrentOfExpr.xpr)
}

// uint32 cvarno = 2 [json_name = "cvarno"];
inline void CurrentOfExpr::clear_cvarno() {
  cvarno_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CurrentOfExpr::_internal_cvarno() const {
  return cvarno_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CurrentOfExpr::cvarno() const {
  // @@protoc_insertion_point(field_get:pg_query.CurrentOfExpr.cvarno)
  return _internal_cvarno();
}
inline void CurrentOfExpr::_internal_set_cvarno(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  cvarno_ = value;
}
inline void CurrentOfExpr::set_cvarno(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_cvarno(value);
  // @@protoc_insertion_point(field_set:pg_query.CurrentOfExpr.cvarno)
}

// string cursor_name = 3 [json_name = "cursor_name"];
inline void CurrentOfExpr::clear_cursor_name() {
  cursor_name_.ClearToEmpty();
}
inline const std::string& CurrentOfExpr::cursor_name() const {
  // @@protoc_insertion_point(field_get:pg_query.CurrentOfExpr.cursor_name)
  return _internal_cursor_name();
}
inline void CurrentOfExpr::set_cursor_name(const std::string& value) {
  _internal_set_cursor_name(value);
  // @@protoc_insertion_point(field_set:pg_query.CurrentOfExpr.cursor_name)
}
inline std::string* CurrentOfExpr::mutable_cursor_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.CurrentOfExpr.cursor_name)
  return _internal_mutable_cursor_name();
}
inline const std::string& CurrentOfExpr::_internal_cursor_name() const {
  return cursor_name_.Get();
}
inline void CurrentOfExpr::_internal_set_cursor_name(const std::string& value) {
  
  cursor_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CurrentOfExpr::set_cursor_name(std::string&& value) {
  
  cursor_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CurrentOfExpr.cursor_name)
}
inline void CurrentOfExpr::set_cursor_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  cursor_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CurrentOfExpr.cursor_name)
}
inline void CurrentOfExpr::set_cursor_name(const char* value,
    size_t size) {
  
  cursor_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CurrentOfExpr.cursor_name)
}
inline std::string* CurrentOfExpr::_internal_mutable_cursor_name() {
  
  return cursor_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CurrentOfExpr::release_cursor_name() {
  // @@protoc_insertion_point(field_release:pg_query.CurrentOfExpr.cursor_name)
  return cursor_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CurrentOfExpr::set_allocated_cursor_name(std::string* cursor_name) {
  if (cursor_name != nullptr) {
    
  } else {
    
  }
  cursor_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cursor_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CurrentOfExpr.cursor_name)
}

// int32 cursor_param = 4 [json_name = "cursor_param"];
inline void CurrentOfExpr::clear_cursor_param() {
  cursor_param_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CurrentOfExpr::_internal_cursor_param() const {
  return cursor_param_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CurrentOfExpr::cursor_param() const {
  // @@protoc_insertion_point(field_get:pg_query.CurrentOfExpr.cursor_param)
  return _internal_cursor_param();
}
inline void CurrentOfExpr::_internal_set_cursor_param(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  cursor_param_ = value;
}
inline void CurrentOfExpr::set_cursor_param(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_cursor_param(value);
  // @@protoc_insertion_point(field_set:pg_query.CurrentOfExpr.cursor_param)
}

// -------------------------------------------------------------------

// NextValueExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool NextValueExpr::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool NextValueExpr::has_xpr() const {
  return _internal_has_xpr();
}
inline void NextValueExpr::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& NextValueExpr::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& NextValueExpr::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.NextValueExpr.xpr)
  return _internal_xpr();
}
inline void NextValueExpr::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NextValueExpr.xpr)
}
inline ::pg_query::Node* NextValueExpr::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* NextValueExpr::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.NextValueExpr.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* NextValueExpr::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* NextValueExpr::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.NextValueExpr.xpr)
  return _internal_mutable_xpr();
}
inline void NextValueExpr::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.NextValueExpr.xpr)
}

// uint32 seqid = 2 [json_name = "seqid"];
inline void NextValueExpr::clear_seqid() {
  seqid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NextValueExpr::_internal_seqid() const {
  return seqid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NextValueExpr::seqid() const {
  // @@protoc_insertion_point(field_get:pg_query.NextValueExpr.seqid)
  return _internal_seqid();
}
inline void NextValueExpr::_internal_set_seqid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  seqid_ = value;
}
inline void NextValueExpr::set_seqid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_seqid(value);
  // @@protoc_insertion_point(field_set:pg_query.NextValueExpr.seqid)
}

// uint32 type_id = 3 [json_name = "typeId"];
inline void NextValueExpr::clear_type_id() {
  type_id_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NextValueExpr::_internal_type_id() const {
  return type_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 NextValueExpr::type_id() const {
  // @@protoc_insertion_point(field_get:pg_query.NextValueExpr.type_id)
  return _internal_type_id();
}
inline void NextValueExpr::_internal_set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  type_id_ = value;
}
inline void NextValueExpr::set_type_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_type_id(value);
  // @@protoc_insertion_point(field_set:pg_query.NextValueExpr.type_id)
}

// -------------------------------------------------------------------

// InferenceElem

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool InferenceElem::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool InferenceElem::has_xpr() const {
  return _internal_has_xpr();
}
inline void InferenceElem::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& InferenceElem::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& InferenceElem::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.InferenceElem.xpr)
  return _internal_xpr();
}
inline void InferenceElem::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InferenceElem.xpr)
}
inline ::pg_query::Node* InferenceElem::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* InferenceElem::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.InferenceElem.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* InferenceElem::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* InferenceElem::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.InferenceElem.xpr)
  return _internal_mutable_xpr();
}
inline void InferenceElem::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.InferenceElem.xpr)
}

// .pg_query.Node expr = 2 [json_name = "expr"];
inline bool InferenceElem::_internal_has_expr() const {
  return this != internal_default_instance() && expr_ != nullptr;
}
inline bool InferenceElem::has_expr() const {
  return _internal_has_expr();
}
inline void InferenceElem::clear_expr() {
  if (GetArena() == nullptr && expr_ != nullptr) {
    delete expr_;
  }
  expr_ = nullptr;
}
inline const ::pg_query::Node& InferenceElem::_internal_expr() const {
  const ::pg_query::Node* p = expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& InferenceElem::expr() const {
  // @@protoc_insertion_point(field_get:pg_query.InferenceElem.expr)
  return _internal_expr();
}
inline void InferenceElem::unsafe_arena_set_allocated_expr(
    ::pg_query::Node* expr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expr_);
  }
  expr_ = expr;
  if (expr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InferenceElem.expr)
}
inline ::pg_query::Node* InferenceElem::release_expr() {
  
  ::pg_query::Node* temp = expr_;
  expr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* InferenceElem::unsafe_arena_release_expr() {
  // @@protoc_insertion_point(field_release:pg_query.InferenceElem.expr)
  
  ::pg_query::Node* temp = expr_;
  expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* InferenceElem::_internal_mutable_expr() {
  
  if (expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    expr_ = p;
  }
  return expr_;
}
inline ::pg_query::Node* InferenceElem::mutable_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.InferenceElem.expr)
  return _internal_mutable_expr();
}
inline void InferenceElem::set_allocated_expr(::pg_query::Node* expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete expr_;
  }
  if (expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expr);
    if (message_arena != submessage_arena) {
      expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, expr, submessage_arena);
    }
    
  } else {
    
  }
  expr_ = expr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.InferenceElem.expr)
}

// uint32 infercollid = 3 [json_name = "infercollid"];
inline void InferenceElem::clear_infercollid() {
  infercollid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 InferenceElem::_internal_infercollid() const {
  return infercollid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 InferenceElem::infercollid() const {
  // @@protoc_insertion_point(field_get:pg_query.InferenceElem.infercollid)
  return _internal_infercollid();
}
inline void InferenceElem::_internal_set_infercollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  infercollid_ = value;
}
inline void InferenceElem::set_infercollid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_infercollid(value);
  // @@protoc_insertion_point(field_set:pg_query.InferenceElem.infercollid)
}

// uint32 inferopclass = 4 [json_name = "inferopclass"];
inline void InferenceElem::clear_inferopclass() {
  inferopclass_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 InferenceElem::_internal_inferopclass() const {
  return inferopclass_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 InferenceElem::inferopclass() const {
  // @@protoc_insertion_point(field_get:pg_query.InferenceElem.inferopclass)
  return _internal_inferopclass();
}
inline void InferenceElem::_internal_set_inferopclass(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  inferopclass_ = value;
}
inline void InferenceElem::set_inferopclass(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_inferopclass(value);
  // @@protoc_insertion_point(field_set:pg_query.InferenceElem.inferopclass)
}

// -------------------------------------------------------------------

// TargetEntry

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool TargetEntry::_internal_has_xpr() const {
  return this != internal_default_instance() && xpr_ != nullptr;
}
inline bool TargetEntry::has_xpr() const {
  return _internal_has_xpr();
}
inline void TargetEntry::clear_xpr() {
  if (GetArena() == nullptr && xpr_ != nullptr) {
    delete xpr_;
  }
  xpr_ = nullptr;
}
inline const ::pg_query::Node& TargetEntry::_internal_xpr() const {
  const ::pg_query::Node* p = xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& TargetEntry::xpr() const {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.xpr)
  return _internal_xpr();
}
inline void TargetEntry::unsafe_arena_set_allocated_xpr(
    ::pg_query::Node* xpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xpr_);
  }
  xpr_ = xpr;
  if (xpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TargetEntry.xpr)
}
inline ::pg_query::Node* TargetEntry::release_xpr() {
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* TargetEntry::unsafe_arena_release_xpr() {
  // @@protoc_insertion_point(field_release:pg_query.TargetEntry.xpr)
  
  ::pg_query::Node* temp = xpr_;
  xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* TargetEntry::_internal_mutable_xpr() {
  
  if (xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    xpr_ = p;
  }
  return xpr_;
}
inline ::pg_query::Node* TargetEntry::mutable_xpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.TargetEntry.xpr)
  return _internal_mutable_xpr();
}
inline void TargetEntry::set_allocated_xpr(::pg_query::Node* xpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete xpr_;
  }
  if (xpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(xpr);
    if (message_arena != submessage_arena) {
      xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, xpr, submessage_arena);
    }
    
  } else {
    
  }
  xpr_ = xpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.TargetEntry.xpr)
}

// .pg_query.Node expr = 2 [json_name = "expr"];
inline bool TargetEntry::_internal_has_expr() const {
  return this != internal_default_instance() && expr_ != nullptr;
}
inline bool TargetEntry::has_expr() const {
  return _internal_has_expr();
}
inline void TargetEntry::clear_expr() {
  if (GetArena() == nullptr && expr_ != nullptr) {
    delete expr_;
  }
  expr_ = nullptr;
}
inline const ::pg_query::Node& TargetEntry::_internal_expr() const {
  const ::pg_query::Node* p = expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& TargetEntry::expr() const {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.expr)
  return _internal_expr();
}
inline void TargetEntry::unsafe_arena_set_allocated_expr(
    ::pg_query::Node* expr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expr_);
  }
  expr_ = expr;
  if (expr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TargetEntry.expr)
}
inline ::pg_query::Node* TargetEntry::release_expr() {
  
  ::pg_query::Node* temp = expr_;
  expr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* TargetEntry::unsafe_arena_release_expr() {
  // @@protoc_insertion_point(field_release:pg_query.TargetEntry.expr)
  
  ::pg_query::Node* temp = expr_;
  expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* TargetEntry::_internal_mutable_expr() {
  
  if (expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    expr_ = p;
  }
  return expr_;
}
inline ::pg_query::Node* TargetEntry::mutable_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.TargetEntry.expr)
  return _internal_mutable_expr();
}
inline void TargetEntry::set_allocated_expr(::pg_query::Node* expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete expr_;
  }
  if (expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expr);
    if (message_arena != submessage_arena) {
      expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, expr, submessage_arena);
    }
    
  } else {
    
  }
  expr_ = expr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.TargetEntry.expr)
}

// int32 resno = 3 [json_name = "resno"];
inline void TargetEntry::clear_resno() {
  resno_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TargetEntry::_internal_resno() const {
  return resno_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TargetEntry::resno() const {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resno)
  return _internal_resno();
}
inline void TargetEntry::_internal_set_resno(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  resno_ = value;
}
inline void TargetEntry::set_resno(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_resno(value);
  // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resno)
}

// string resname = 4 [json_name = "resname"];
inline void TargetEntry::clear_resname() {
  resname_.ClearToEmpty();
}
inline const std::string& TargetEntry::resname() const {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resname)
  return _internal_resname();
}
inline void TargetEntry::set_resname(const std::string& value) {
  _internal_set_resname(value);
  // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resname)
}
inline std::string* TargetEntry::mutable_resname() {
  // @@protoc_insertion_point(field_mutable:pg_query.TargetEntry.resname)
  return _internal_mutable_resname();
}
inline const std::string& TargetEntry::_internal_resname() const {
  return resname_.Get();
}
inline void TargetEntry::_internal_set_resname(const std::string& value) {
  
  resname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void TargetEntry::set_resname(std::string&& value) {
  
  resname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.TargetEntry.resname)
}
inline void TargetEntry::set_resname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  resname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.TargetEntry.resname)
}
inline void TargetEntry::set_resname(const char* value,
    size_t size) {
  
  resname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.TargetEntry.resname)
}
inline std::string* TargetEntry::_internal_mutable_resname() {
  
  return resname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* TargetEntry::release_resname() {
  // @@protoc_insertion_point(field_release:pg_query.TargetEntry.resname)
  return resname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void TargetEntry::set_allocated_resname(std::string* resname) {
  if (resname != nullptr) {
    
  } else {
    
  }
  resname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), resname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.TargetEntry.resname)
}

// uint32 ressortgroupref = 5 [json_name = "ressortgroupref"];
inline void TargetEntry::clear_ressortgroupref() {
  ressortgroupref_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TargetEntry::_internal_ressortgroupref() const {
  return ressortgroupref_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TargetEntry::ressortgroupref() const {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.ressortgroupref)
  return _internal_ressortgroupref();
}
inline void TargetEntry::_internal_set_ressortgroupref(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  ressortgroupref_ = value;
}
inline void TargetEntry::set_ressortgroupref(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_ressortgroupref(value);
  // @@protoc_insertion_point(field_set:pg_query.TargetEntry.ressortgroupref)
}

// uint32 resorigtbl = 6 [json_name = "resorigtbl"];
inline void TargetEntry::clear_resorigtbl() {
  resorigtbl_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TargetEntry::_internal_resorigtbl() const {
  return resorigtbl_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TargetEntry::resorigtbl() const {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resorigtbl)
  return _internal_resorigtbl();
}
inline void TargetEntry::_internal_set_resorigtbl(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  resorigtbl_ = value;
}
inline void TargetEntry::set_resorigtbl(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resorigtbl(value);
  // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resorigtbl)
}

// int32 resorigcol = 7 [json_name = "resorigcol"];
inline void TargetEntry::clear_resorigcol() {
  resorigcol_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TargetEntry::_internal_resorigcol() const {
  return resorigcol_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TargetEntry::resorigcol() const {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resorigcol)
  return _internal_resorigcol();
}
inline void TargetEntry::_internal_set_resorigcol(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  resorigcol_ = value;
}
inline void TargetEntry::set_resorigcol(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_resorigcol(value);
  // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resorigcol)
}

// bool resjunk = 8 [json_name = "resjunk"];
inline void TargetEntry::clear_resjunk() {
  resjunk_ = false;
}
inline bool TargetEntry::_internal_resjunk() const {
  return resjunk_;
}
inline bool TargetEntry::resjunk() const {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resjunk)
  return _internal_resjunk();
}
inline void TargetEntry::_internal_set_resjunk(bool value) {
  
  resjunk_ = value;
}
inline void TargetEntry::set_resjunk(bool value) {
  _internal_set_resjunk(value);
  // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resjunk)
}

// -------------------------------------------------------------------

// RangeTblRef

// int32 rtindex = 1 [json_name = "rtindex"];
inline void RangeTblRef::clear_rtindex() {
  rtindex_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTblRef::_internal_rtindex() const {
  return rtindex_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTblRef::rtindex() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblRef.rtindex)
  return _internal_rtindex();
}
inline void RangeTblRef::_internal_set_rtindex(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  rtindex_ = value;
}
inline void RangeTblRef::set_rtindex(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_rtindex(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblRef.rtindex)
}

// -------------------------------------------------------------------

// JoinExpr

// .pg_query.JoinType jointype = 1 [json_name = "jointype"];
inline void JoinExpr::clear_jointype() {
  jointype_ = 0;
}
inline ::pg_query::JoinType JoinExpr::_internal_jointype() const {
  return static_cast< ::pg_query::JoinType >(jointype_);
}
inline ::pg_query::JoinType JoinExpr::jointype() const {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.jointype)
  return _internal_jointype();
}
inline void JoinExpr::_internal_set_jointype(::pg_query::JoinType value) {
  
  jointype_ = value;
}
inline void JoinExpr::set_jointype(::pg_query::JoinType value) {
  _internal_set_jointype(value);
  // @@protoc_insertion_point(field_set:pg_query.JoinExpr.jointype)
}

// bool is_natural = 2 [json_name = "isNatural"];
inline void JoinExpr::clear_is_natural() {
  is_natural_ = false;
}
inline bool JoinExpr::_internal_is_natural() const {
  return is_natural_;
}
inline bool JoinExpr::is_natural() const {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.is_natural)
  return _internal_is_natural();
}
inline void JoinExpr::_internal_set_is_natural(bool value) {
  
  is_natural_ = value;
}
inline void JoinExpr::set_is_natural(bool value) {
  _internal_set_is_natural(value);
  // @@protoc_insertion_point(field_set:pg_query.JoinExpr.is_natural)
}

// .pg_query.Node larg = 3 [json_name = "larg"];
inline bool JoinExpr::_internal_has_larg() const {
  return this != internal_default_instance() && larg_ != nullptr;
}
inline bool JoinExpr::has_larg() const {
  return _internal_has_larg();
}
inline void JoinExpr::clear_larg() {
  if (GetArena() == nullptr && larg_ != nullptr) {
    delete larg_;
  }
  larg_ = nullptr;
}
inline const ::pg_query::Node& JoinExpr::_internal_larg() const {
  const ::pg_query::Node* p = larg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JoinExpr::larg() const {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.larg)
  return _internal_larg();
}
inline void JoinExpr::unsafe_arena_set_allocated_larg(
    ::pg_query::Node* larg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(larg_);
  }
  larg_ = larg;
  if (larg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.larg)
}
inline ::pg_query::Node* JoinExpr::release_larg() {
  
  ::pg_query::Node* temp = larg_;
  larg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* JoinExpr::unsafe_arena_release_larg() {
  // @@protoc_insertion_point(field_release:pg_query.JoinExpr.larg)
  
  ::pg_query::Node* temp = larg_;
  larg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JoinExpr::_internal_mutable_larg() {
  
  if (larg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    larg_ = p;
  }
  return larg_;
}
inline ::pg_query::Node* JoinExpr::mutable_larg() {
  // @@protoc_insertion_point(field_mutable:pg_query.JoinExpr.larg)
  return _internal_mutable_larg();
}
inline void JoinExpr::set_allocated_larg(::pg_query::Node* larg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete larg_;
  }
  if (larg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(larg);
    if (message_arena != submessage_arena) {
      larg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, larg, submessage_arena);
    }
    
  } else {
    
  }
  larg_ = larg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.JoinExpr.larg)
}

// .pg_query.Node rarg = 4 [json_name = "rarg"];
inline bool JoinExpr::_internal_has_rarg() const {
  return this != internal_default_instance() && rarg_ != nullptr;
}
inline bool JoinExpr::has_rarg() const {
  return _internal_has_rarg();
}
inline void JoinExpr::clear_rarg() {
  if (GetArena() == nullptr && rarg_ != nullptr) {
    delete rarg_;
  }
  rarg_ = nullptr;
}
inline const ::pg_query::Node& JoinExpr::_internal_rarg() const {
  const ::pg_query::Node* p = rarg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JoinExpr::rarg() const {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.rarg)
  return _internal_rarg();
}
inline void JoinExpr::unsafe_arena_set_allocated_rarg(
    ::pg_query::Node* rarg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rarg_);
  }
  rarg_ = rarg;
  if (rarg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.rarg)
}
inline ::pg_query::Node* JoinExpr::release_rarg() {
  
  ::pg_query::Node* temp = rarg_;
  rarg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* JoinExpr::unsafe_arena_release_rarg() {
  // @@protoc_insertion_point(field_release:pg_query.JoinExpr.rarg)
  
  ::pg_query::Node* temp = rarg_;
  rarg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JoinExpr::_internal_mutable_rarg() {
  
  if (rarg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    rarg_ = p;
  }
  return rarg_;
}
inline ::pg_query::Node* JoinExpr::mutable_rarg() {
  // @@protoc_insertion_point(field_mutable:pg_query.JoinExpr.rarg)
  return _internal_mutable_rarg();
}
inline void JoinExpr::set_allocated_rarg(::pg_query::Node* rarg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete rarg_;
  }
  if (rarg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(rarg);
    if (message_arena != submessage_arena) {
      rarg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rarg, submessage_arena);
    }
    
  } else {
    
  }
  rarg_ = rarg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.JoinExpr.rarg)
}

// repeated .pg_query.Node using_clause = 5 [json_name = "usingClause"];
inline int JoinExpr::_internal_using_clause_size() const {
  return using_clause_.size();
}
inline int JoinExpr::using_clause_size() const {
  return _internal_using_clause_size();
}
inline void JoinExpr::clear_using_clause() {
  using_clause_.Clear();
}
inline ::pg_query::Node* JoinExpr::mutable_using_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.JoinExpr.using_clause)
  return using_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
JoinExpr::mutable_using_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.JoinExpr.using_clause)
  return &using_clause_;
}
inline const ::pg_query::Node& JoinExpr::_internal_using_clause(int index) const {
  return using_clause_.Get(index);
}
inline const ::pg_query::Node& JoinExpr::using_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.using_clause)
  return _internal_using_clause(index);
}
inline ::pg_query::Node* JoinExpr::_internal_add_using_clause() {
  return using_clause_.Add();
}
inline ::pg_query::Node* JoinExpr::add_using_clause() {
  // @@protoc_insertion_point(field_add:pg_query.JoinExpr.using_clause)
  return _internal_add_using_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
JoinExpr::using_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.JoinExpr.using_clause)
  return using_clause_;
}

// .pg_query.Node quals = 6 [json_name = "quals"];
inline bool JoinExpr::_internal_has_quals() const {
  return this != internal_default_instance() && quals_ != nullptr;
}
inline bool JoinExpr::has_quals() const {
  return _internal_has_quals();
}
inline void JoinExpr::clear_quals() {
  if (GetArena() == nullptr && quals_ != nullptr) {
    delete quals_;
  }
  quals_ = nullptr;
}
inline const ::pg_query::Node& JoinExpr::_internal_quals() const {
  const ::pg_query::Node* p = quals_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JoinExpr::quals() const {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.quals)
  return _internal_quals();
}
inline void JoinExpr::unsafe_arena_set_allocated_quals(
    ::pg_query::Node* quals) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quals_);
  }
  quals_ = quals;
  if (quals) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.quals)
}
inline ::pg_query::Node* JoinExpr::release_quals() {
  
  ::pg_query::Node* temp = quals_;
  quals_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* JoinExpr::unsafe_arena_release_quals() {
  // @@protoc_insertion_point(field_release:pg_query.JoinExpr.quals)
  
  ::pg_query::Node* temp = quals_;
  quals_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JoinExpr::_internal_mutable_quals() {
  
  if (quals_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    quals_ = p;
  }
  return quals_;
}
inline ::pg_query::Node* JoinExpr::mutable_quals() {
  // @@protoc_insertion_point(field_mutable:pg_query.JoinExpr.quals)
  return _internal_mutable_quals();
}
inline void JoinExpr::set_allocated_quals(::pg_query::Node* quals) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete quals_;
  }
  if (quals) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(quals);
    if (message_arena != submessage_arena) {
      quals = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quals, submessage_arena);
    }
    
  } else {
    
  }
  quals_ = quals;
  // @@protoc_insertion_point(field_set_allocated:pg_query.JoinExpr.quals)
}

// .pg_query.Alias alias = 7 [json_name = "alias"];
inline bool JoinExpr::_internal_has_alias() const {
  return this != internal_default_instance() && alias_ != nullptr;
}
inline bool JoinExpr::has_alias() const {
  return _internal_has_alias();
}
inline void JoinExpr::clear_alias() {
  if (GetArena() == nullptr && alias_ != nullptr) {
    delete alias_;
  }
  alias_ = nullptr;
}
inline const ::pg_query::Alias& JoinExpr::_internal_alias() const {
  const ::pg_query::Alias* p = alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(
      ::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& JoinExpr::alias() const {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.alias)
  return _internal_alias();
}
inline void JoinExpr::unsafe_arena_set_allocated_alias(
    ::pg_query::Alias* alias) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alias_);
  }
  alias_ = alias;
  if (alias) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.alias)
}
inline ::pg_query::Alias* JoinExpr::release_alias() {
  
  ::pg_query::Alias* temp = alias_;
  alias_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Alias* JoinExpr::unsafe_arena_release_alias() {
  // @@protoc_insertion_point(field_release:pg_query.JoinExpr.alias)
  
  ::pg_query::Alias* temp = alias_;
  alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* JoinExpr::_internal_mutable_alias() {
  
  if (alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    alias_ = p;
  }
  return alias_;
}
inline ::pg_query::Alias* JoinExpr::mutable_alias() {
  // @@protoc_insertion_point(field_mutable:pg_query.JoinExpr.alias)
  return _internal_mutable_alias();
}
inline void JoinExpr::set_allocated_alias(::pg_query::Alias* alias) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete alias_;
  }
  if (alias) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(alias);
    if (message_arena != submessage_arena) {
      alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, alias, submessage_arena);
    }
    
  } else {
    
  }
  alias_ = alias;
  // @@protoc_insertion_point(field_set_allocated:pg_query.JoinExpr.alias)
}

// int32 rtindex = 8 [json_name = "rtindex"];
inline void JoinExpr::clear_rtindex() {
  rtindex_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 JoinExpr::_internal_rtindex() const {
  return rtindex_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 JoinExpr::rtindex() const {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.rtindex)
  return _internal_rtindex();
}
inline void JoinExpr::_internal_set_rtindex(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  rtindex_ = value;
}
inline void JoinExpr::set_rtindex(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_rtindex(value);
  // @@protoc_insertion_point(field_set:pg_query.JoinExpr.rtindex)
}

// -------------------------------------------------------------------

// FromExpr

// repeated .pg_query.Node fromlist = 1 [json_name = "fromlist"];
inline int FromExpr::_internal_fromlist_size() const {
  return fromlist_.size();
}
inline int FromExpr::fromlist_size() const {
  return _internal_fromlist_size();
}
inline void FromExpr::clear_fromlist() {
  fromlist_.Clear();
}
inline ::pg_query::Node* FromExpr::mutable_fromlist(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.FromExpr.fromlist)
  return fromlist_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
FromExpr::mutable_fromlist() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FromExpr.fromlist)
  return &fromlist_;
}
inline const ::pg_query::Node& FromExpr::_internal_fromlist(int index) const {
  return fromlist_.Get(index);
}
inline const ::pg_query::Node& FromExpr::fromlist(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.FromExpr.fromlist)
  return _internal_fromlist(index);
}
inline ::pg_query::Node* FromExpr::_internal_add_fromlist() {
  return fromlist_.Add();
}
inline ::pg_query::Node* FromExpr::add_fromlist() {
  // @@protoc_insertion_point(field_add:pg_query.FromExpr.fromlist)
  return _internal_add_fromlist();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
FromExpr::fromlist() const {
  // @@protoc_insertion_point(field_list:pg_query.FromExpr.fromlist)
  return fromlist_;
}

// .pg_query.Node quals = 2 [json_name = "quals"];
inline bool FromExpr::_internal_has_quals() const {
  return this != internal_default_instance() && quals_ != nullptr;
}
inline bool FromExpr::has_quals() const {
  return _internal_has_quals();
}
inline void FromExpr::clear_quals() {
  if (GetArena() == nullptr && quals_ != nullptr) {
    delete quals_;
  }
  quals_ = nullptr;
}
inline const ::pg_query::Node& FromExpr::_internal_quals() const {
  const ::pg_query::Node* p = quals_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FromExpr::quals() const {
  // @@protoc_insertion_point(field_get:pg_query.FromExpr.quals)
  return _internal_quals();
}
inline void FromExpr::unsafe_arena_set_allocated_quals(
    ::pg_query::Node* quals) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quals_);
  }
  quals_ = quals;
  if (quals) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FromExpr.quals)
}
inline ::pg_query::Node* FromExpr::release_quals() {
  
  ::pg_query::Node* temp = quals_;
  quals_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* FromExpr::unsafe_arena_release_quals() {
  // @@protoc_insertion_point(field_release:pg_query.FromExpr.quals)
  
  ::pg_query::Node* temp = quals_;
  quals_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FromExpr::_internal_mutable_quals() {
  
  if (quals_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    quals_ = p;
  }
  return quals_;
}
inline ::pg_query::Node* FromExpr::mutable_quals() {
  // @@protoc_insertion_point(field_mutable:pg_query.FromExpr.quals)
  return _internal_mutable_quals();
}
inline void FromExpr::set_allocated_quals(::pg_query::Node* quals) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete quals_;
  }
  if (quals) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(quals);
    if (message_arena != submessage_arena) {
      quals = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quals, submessage_arena);
    }
    
  } else {
    
  }
  quals_ = quals;
  // @@protoc_insertion_point(field_set_allocated:pg_query.FromExpr.quals)
}

// -------------------------------------------------------------------

// OnConflictExpr

// .pg_query.OnConflictAction action = 1 [json_name = "action"];
inline void OnConflictExpr::clear_action() {
  action_ = 0;
}
inline ::pg_query::OnConflictAction OnConflictExpr::_internal_action() const {
  return static_cast< ::pg_query::OnConflictAction >(action_);
}
inline ::pg_query::OnConflictAction OnConflictExpr::action() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.action)
  return _internal_action();
}
inline void OnConflictExpr::_internal_set_action(::pg_query::OnConflictAction value) {
  
  action_ = value;
}
inline void OnConflictExpr::set_action(::pg_query::OnConflictAction value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:pg_query.OnConflictExpr.action)
}

// repeated .pg_query.Node arbiter_elems = 2 [json_name = "arbiterElems"];
inline int OnConflictExpr::_internal_arbiter_elems_size() const {
  return arbiter_elems_.size();
}
inline int OnConflictExpr::arbiter_elems_size() const {
  return _internal_arbiter_elems_size();
}
inline void OnConflictExpr::clear_arbiter_elems() {
  arbiter_elems_.Clear();
}
inline ::pg_query::Node* OnConflictExpr::mutable_arbiter_elems(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictExpr.arbiter_elems)
  return arbiter_elems_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
OnConflictExpr::mutable_arbiter_elems() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.OnConflictExpr.arbiter_elems)
  return &arbiter_elems_;
}
inline const ::pg_query::Node& OnConflictExpr::_internal_arbiter_elems(int index) const {
  return arbiter_elems_.Get(index);
}
inline const ::pg_query::Node& OnConflictExpr::arbiter_elems(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.arbiter_elems)
  return _internal_arbiter_elems(index);
}
inline ::pg_query::Node* OnConflictExpr::_internal_add_arbiter_elems() {
  return arbiter_elems_.Add();
}
inline ::pg_query::Node* OnConflictExpr::add_arbiter_elems() {
  // @@protoc_insertion_point(field_add:pg_query.OnConflictExpr.arbiter_elems)
  return _internal_add_arbiter_elems();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
OnConflictExpr::arbiter_elems() const {
  // @@protoc_insertion_point(field_list:pg_query.OnConflictExpr.arbiter_elems)
  return arbiter_elems_;
}

// .pg_query.Node arbiter_where = 3 [json_name = "arbiterWhere"];
inline bool OnConflictExpr::_internal_has_arbiter_where() const {
  return this != internal_default_instance() && arbiter_where_ != nullptr;
}
inline bool OnConflictExpr::has_arbiter_where() const {
  return _internal_has_arbiter_where();
}
inline void OnConflictExpr::clear_arbiter_where() {
  if (GetArena() == nullptr && arbiter_where_ != nullptr) {
    delete arbiter_where_;
  }
  arbiter_where_ = nullptr;
}
inline const ::pg_query::Node& OnConflictExpr::_internal_arbiter_where() const {
  const ::pg_query::Node* p = arbiter_where_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& OnConflictExpr::arbiter_where() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.arbiter_where)
  return _internal_arbiter_where();
}
inline void OnConflictExpr::unsafe_arena_set_allocated_arbiter_where(
    ::pg_query::Node* arbiter_where) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arbiter_where_);
  }
  arbiter_where_ = arbiter_where;
  if (arbiter_where) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OnConflictExpr.arbiter_where)
}
inline ::pg_query::Node* OnConflictExpr::release_arbiter_where() {
  
  ::pg_query::Node* temp = arbiter_where_;
  arbiter_where_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* OnConflictExpr::unsafe_arena_release_arbiter_where() {
  // @@protoc_insertion_point(field_release:pg_query.OnConflictExpr.arbiter_where)
  
  ::pg_query::Node* temp = arbiter_where_;
  arbiter_where_ = nullptr;
  return temp;
}
inline ::pg_query::Node* OnConflictExpr::_internal_mutable_arbiter_where() {
  
  if (arbiter_where_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arbiter_where_ = p;
  }
  return arbiter_where_;
}
inline ::pg_query::Node* OnConflictExpr::mutable_arbiter_where() {
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictExpr.arbiter_where)
  return _internal_mutable_arbiter_where();
}
inline void OnConflictExpr::set_allocated_arbiter_where(::pg_query::Node* arbiter_where) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arbiter_where_;
  }
  if (arbiter_where) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arbiter_where);
    if (message_arena != submessage_arena) {
      arbiter_where = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arbiter_where, submessage_arena);
    }
    
  } else {
    
  }
  arbiter_where_ = arbiter_where;
  // @@protoc_insertion_point(field_set_allocated:pg_query.OnConflictExpr.arbiter_where)
}

// uint32 constraint = 4 [json_name = "constraint"];
inline void OnConflictExpr::clear_constraint() {
  constraint_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 OnConflictExpr::_internal_constraint() const {
  return constraint_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 OnConflictExpr::constraint() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.constraint)
  return _internal_constraint();
}
inline void OnConflictExpr::_internal_set_constraint(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  constraint_ = value;
}
inline void OnConflictExpr::set_constraint(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_constraint(value);
  // @@protoc_insertion_point(field_set:pg_query.OnConflictExpr.constraint)
}

// repeated .pg_query.Node on_conflict_set = 5 [json_name = "onConflictSet"];
inline int OnConflictExpr::_internal_on_conflict_set_size() const {
  return on_conflict_set_.size();
}
inline int OnConflictExpr::on_conflict_set_size() const {
  return _internal_on_conflict_set_size();
}
inline void OnConflictExpr::clear_on_conflict_set() {
  on_conflict_set_.Clear();
}
inline ::pg_query::Node* OnConflictExpr::mutable_on_conflict_set(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictExpr.on_conflict_set)
  return on_conflict_set_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
OnConflictExpr::mutable_on_conflict_set() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.OnConflictExpr.on_conflict_set)
  return &on_conflict_set_;
}
inline const ::pg_query::Node& OnConflictExpr::_internal_on_conflict_set(int index) const {
  return on_conflict_set_.Get(index);
}
inline const ::pg_query::Node& OnConflictExpr::on_conflict_set(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.on_conflict_set)
  return _internal_on_conflict_set(index);
}
inline ::pg_query::Node* OnConflictExpr::_internal_add_on_conflict_set() {
  return on_conflict_set_.Add();
}
inline ::pg_query::Node* OnConflictExpr::add_on_conflict_set() {
  // @@protoc_insertion_point(field_add:pg_query.OnConflictExpr.on_conflict_set)
  return _internal_add_on_conflict_set();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
OnConflictExpr::on_conflict_set() const {
  // @@protoc_insertion_point(field_list:pg_query.OnConflictExpr.on_conflict_set)
  return on_conflict_set_;
}

// .pg_query.Node on_conflict_where = 6 [json_name = "onConflictWhere"];
inline bool OnConflictExpr::_internal_has_on_conflict_where() const {
  return this != internal_default_instance() && on_conflict_where_ != nullptr;
}
inline bool OnConflictExpr::has_on_conflict_where() const {
  return _internal_has_on_conflict_where();
}
inline void OnConflictExpr::clear_on_conflict_where() {
  if (GetArena() == nullptr && on_conflict_where_ != nullptr) {
    delete on_conflict_where_;
  }
  on_conflict_where_ = nullptr;
}
inline const ::pg_query::Node& OnConflictExpr::_internal_on_conflict_where() const {
  const ::pg_query::Node* p = on_conflict_where_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& OnConflictExpr::on_conflict_where() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.on_conflict_where)
  return _internal_on_conflict_where();
}
inline void OnConflictExpr::unsafe_arena_set_allocated_on_conflict_where(
    ::pg_query::Node* on_conflict_where) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(on_conflict_where_);
  }
  on_conflict_where_ = on_conflict_where;
  if (on_conflict_where) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OnConflictExpr.on_conflict_where)
}
inline ::pg_query::Node* OnConflictExpr::release_on_conflict_where() {
  
  ::pg_query::Node* temp = on_conflict_where_;
  on_conflict_where_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* OnConflictExpr::unsafe_arena_release_on_conflict_where() {
  // @@protoc_insertion_point(field_release:pg_query.OnConflictExpr.on_conflict_where)
  
  ::pg_query::Node* temp = on_conflict_where_;
  on_conflict_where_ = nullptr;
  return temp;
}
inline ::pg_query::Node* OnConflictExpr::_internal_mutable_on_conflict_where() {
  
  if (on_conflict_where_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    on_conflict_where_ = p;
  }
  return on_conflict_where_;
}
inline ::pg_query::Node* OnConflictExpr::mutable_on_conflict_where() {
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictExpr.on_conflict_where)
  return _internal_mutable_on_conflict_where();
}
inline void OnConflictExpr::set_allocated_on_conflict_where(::pg_query::Node* on_conflict_where) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete on_conflict_where_;
  }
  if (on_conflict_where) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(on_conflict_where);
    if (message_arena != submessage_arena) {
      on_conflict_where = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, on_conflict_where, submessage_arena);
    }
    
  } else {
    
  }
  on_conflict_where_ = on_conflict_where;
  // @@protoc_insertion_point(field_set_allocated:pg_query.OnConflictExpr.on_conflict_where)
}

// int32 excl_rel_index = 7 [json_name = "exclRelIndex"];
inline void OnConflictExpr::clear_excl_rel_index() {
  excl_rel_index_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 OnConflictExpr::_internal_excl_rel_index() const {
  return excl_rel_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 OnConflictExpr::excl_rel_index() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.excl_rel_index)
  return _internal_excl_rel_index();
}
inline void OnConflictExpr::_internal_set_excl_rel_index(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  excl_rel_index_ = value;
}
inline void OnConflictExpr::set_excl_rel_index(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_excl_rel_index(value);
  // @@protoc_insertion_point(field_set:pg_query.OnConflictExpr.excl_rel_index)
}

// repeated .pg_query.Node excl_rel_tlist = 8 [json_name = "exclRelTlist"];
inline int OnConflictExpr::_internal_excl_rel_tlist_size() const {
  return excl_rel_tlist_.size();
}
inline int OnConflictExpr::excl_rel_tlist_size() const {
  return _internal_excl_rel_tlist_size();
}
inline void OnConflictExpr::clear_excl_rel_tlist() {
  excl_rel_tlist_.Clear();
}
inline ::pg_query::Node* OnConflictExpr::mutable_excl_rel_tlist(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictExpr.excl_rel_tlist)
  return excl_rel_tlist_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
OnConflictExpr::mutable_excl_rel_tlist() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.OnConflictExpr.excl_rel_tlist)
  return &excl_rel_tlist_;
}
inline const ::pg_query::Node& OnConflictExpr::_internal_excl_rel_tlist(int index) const {
  return excl_rel_tlist_.Get(index);
}
inline const ::pg_query::Node& OnConflictExpr::excl_rel_tlist(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.excl_rel_tlist)
  return _internal_excl_rel_tlist(index);
}
inline ::pg_query::Node* OnConflictExpr::_internal_add_excl_rel_tlist() {
  return excl_rel_tlist_.Add();
}
inline ::pg_query::Node* OnConflictExpr::add_excl_rel_tlist() {
  // @@protoc_insertion_point(field_add:pg_query.OnConflictExpr.excl_rel_tlist)
  return _internal_add_excl_rel_tlist();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
OnConflictExpr::excl_rel_tlist() const {
  // @@protoc_insertion_point(field_list:pg_query.OnConflictExpr.excl_rel_tlist)
  return excl_rel_tlist_;
}

// -------------------------------------------------------------------

// IntoClause

// .pg_query.RangeVar rel = 1 [json_name = "rel"];
inline bool IntoClause::_internal_has_rel() const {
  return this != internal_default_instance() && rel_ != nullptr;
}
inline bool IntoClause::has_rel() const {
  return _internal_has_rel();
}
inline void IntoClause::clear_rel() {
  if (GetArena() == nullptr && rel_ != nullptr) {
    delete rel_;
  }
  rel_ = nullptr;
}
inline const ::pg_query::RangeVar& IntoClause::_internal_rel() const {
  const ::pg_query::RangeVar* p = rel_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& IntoClause::rel() const {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.rel)
  return _internal_rel();
}
inline void IntoClause::unsafe_arena_set_allocated_rel(
    ::pg_query::RangeVar* rel) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rel_);
  }
  rel_ = rel;
  if (rel) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IntoClause.rel)
}
inline ::pg_query::RangeVar* IntoClause::release_rel() {
  
  ::pg_query::RangeVar* temp = rel_;
  rel_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* IntoClause::unsafe_arena_release_rel() {
  // @@protoc_insertion_point(field_release:pg_query.IntoClause.rel)
  
  ::pg_query::RangeVar* temp = rel_;
  rel_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* IntoClause::_internal_mutable_rel() {
  
  if (rel_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    rel_ = p;
  }
  return rel_;
}
inline ::pg_query::RangeVar* IntoClause::mutable_rel() {
  // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.rel)
  return _internal_mutable_rel();
}
inline void IntoClause::set_allocated_rel(::pg_query::RangeVar* rel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete rel_;
  }
  if (rel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(rel);
    if (message_arena != submessage_arena) {
      rel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rel, submessage_arena);
    }
    
  } else {
    
  }
  rel_ = rel;
  // @@protoc_insertion_point(field_set_allocated:pg_query.IntoClause.rel)
}

// repeated .pg_query.Node col_names = 2 [json_name = "colNames"];
inline int IntoClause::_internal_col_names_size() const {
  return col_names_.size();
}
inline int IntoClause::col_names_size() const {
  return _internal_col_names_size();
}
inline void IntoClause::clear_col_names() {
  col_names_.Clear();
}
inline ::pg_query::Node* IntoClause::mutable_col_names(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.col_names)
  return col_names_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
IntoClause::mutable_col_names() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IntoClause.col_names)
  return &col_names_;
}
inline const ::pg_query::Node& IntoClause::_internal_col_names(int index) const {
  return col_names_.Get(index);
}
inline const ::pg_query::Node& IntoClause::col_names(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.col_names)
  return _internal_col_names(index);
}
inline ::pg_query::Node* IntoClause::_internal_add_col_names() {
  return col_names_.Add();
}
inline ::pg_query::Node* IntoClause::add_col_names() {
  // @@protoc_insertion_point(field_add:pg_query.IntoClause.col_names)
  return _internal_add_col_names();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
IntoClause::col_names() const {
  // @@protoc_insertion_point(field_list:pg_query.IntoClause.col_names)
  return col_names_;
}

// string access_method = 3 [json_name = "accessMethod"];
inline void IntoClause::clear_access_method() {
  access_method_.ClearToEmpty();
}
inline const std::string& IntoClause::access_method() const {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.access_method)
  return _internal_access_method();
}
inline void IntoClause::set_access_method(const std::string& value) {
  _internal_set_access_method(value);
  // @@protoc_insertion_point(field_set:pg_query.IntoClause.access_method)
}
inline std::string* IntoClause::mutable_access_method() {
  // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.access_method)
  return _internal_mutable_access_method();
}
inline const std::string& IntoClause::_internal_access_method() const {
  return access_method_.Get();
}
inline void IntoClause::_internal_set_access_method(const std::string& value) {
  
  access_method_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void IntoClause::set_access_method(std::string&& value) {
  
  access_method_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.IntoClause.access_method)
}
inline void IntoClause::set_access_method(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  access_method_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.IntoClause.access_method)
}
inline void IntoClause::set_access_method(const char* value,
    size_t size) {
  
  access_method_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.IntoClause.access_method)
}
inline std::string* IntoClause::_internal_mutable_access_method() {
  
  return access_method_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* IntoClause::release_access_method() {
  // @@protoc_insertion_point(field_release:pg_query.IntoClause.access_method)
  return access_method_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void IntoClause::set_allocated_access_method(std::string* access_method) {
  if (access_method != nullptr) {
    
  } else {
    
  }
  access_method_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), access_method,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.IntoClause.access_method)
}

// repeated .pg_query.Node options = 4 [json_name = "options"];
inline int IntoClause::_internal_options_size() const {
  return options_.size();
}
inline int IntoClause::options_size() const {
  return _internal_options_size();
}
inline void IntoClause::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* IntoClause::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
IntoClause::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IntoClause.options)
  return &options_;
}
inline const ::pg_query::Node& IntoClause::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& IntoClause::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.options)
  return _internal_options(index);
}
inline ::pg_query::Node* IntoClause::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* IntoClause::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.IntoClause.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
IntoClause::options() const {
  // @@protoc_insertion_point(field_list:pg_query.IntoClause.options)
  return options_;
}

// .pg_query.OnCommitAction on_commit = 5 [json_name = "onCommit"];
inline void IntoClause::clear_on_commit() {
  on_commit_ = 0;
}
inline ::pg_query::OnCommitAction IntoClause::_internal_on_commit() const {
  return static_cast< ::pg_query::OnCommitAction >(on_commit_);
}
inline ::pg_query::OnCommitAction IntoClause::on_commit() const {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.on_commit)
  return _internal_on_commit();
}
inline void IntoClause::_internal_set_on_commit(::pg_query::OnCommitAction value) {
  
  on_commit_ = value;
}
inline void IntoClause::set_on_commit(::pg_query::OnCommitAction value) {
  _internal_set_on_commit(value);
  // @@protoc_insertion_point(field_set:pg_query.IntoClause.on_commit)
}

// string table_space_name = 6 [json_name = "tableSpaceName"];
inline void IntoClause::clear_table_space_name() {
  table_space_name_.ClearToEmpty();
}
inline const std::string& IntoClause::table_space_name() const {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.table_space_name)
  return _internal_table_space_name();
}
inline void IntoClause::set_table_space_name(const std::string& value) {
  _internal_set_table_space_name(value);
  // @@protoc_insertion_point(field_set:pg_query.IntoClause.table_space_name)
}
inline std::string* IntoClause::mutable_table_space_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.table_space_name)
  return _internal_mutable_table_space_name();
}
inline const std::string& IntoClause::_internal_table_space_name() const {
  return table_space_name_.Get();
}
inline void IntoClause::_internal_set_table_space_name(const std::string& value) {
  
  table_space_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void IntoClause::set_table_space_name(std::string&& value) {
  
  table_space_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.IntoClause.table_space_name)
}
inline void IntoClause::set_table_space_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  table_space_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.IntoClause.table_space_name)
}
inline void IntoClause::set_table_space_name(const char* value,
    size_t size) {
  
  table_space_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.IntoClause.table_space_name)
}
inline std::string* IntoClause::_internal_mutable_table_space_name() {
  
  return table_space_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* IntoClause::release_table_space_name() {
  // @@protoc_insertion_point(field_release:pg_query.IntoClause.table_space_name)
  return table_space_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void IntoClause::set_allocated_table_space_name(std::string* table_space_name) {
  if (table_space_name != nullptr) {
    
  } else {
    
  }
  table_space_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_space_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.IntoClause.table_space_name)
}

// .pg_query.Node view_query = 7 [json_name = "viewQuery"];
inline bool IntoClause::_internal_has_view_query() const {
  return this != internal_default_instance() && view_query_ != nullptr;
}
inline bool IntoClause::has_view_query() const {
  return _internal_has_view_query();
}
inline void IntoClause::clear_view_query() {
  if (GetArena() == nullptr && view_query_ != nullptr) {
    delete view_query_;
  }
  view_query_ = nullptr;
}
inline const ::pg_query::Node& IntoClause::_internal_view_query() const {
  const ::pg_query::Node* p = view_query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& IntoClause::view_query() const {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.view_query)
  return _internal_view_query();
}
inline void IntoClause::unsafe_arena_set_allocated_view_query(
    ::pg_query::Node* view_query) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(view_query_);
  }
  view_query_ = view_query;
  if (view_query) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IntoClause.view_query)
}
inline ::pg_query::Node* IntoClause::release_view_query() {
  
  ::pg_query::Node* temp = view_query_;
  view_query_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* IntoClause::unsafe_arena_release_view_query() {
  // @@protoc_insertion_point(field_release:pg_query.IntoClause.view_query)
  
  ::pg_query::Node* temp = view_query_;
  view_query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* IntoClause::_internal_mutable_view_query() {
  
  if (view_query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    view_query_ = p;
  }
  return view_query_;
}
inline ::pg_query::Node* IntoClause::mutable_view_query() {
  // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.view_query)
  return _internal_mutable_view_query();
}
inline void IntoClause::set_allocated_view_query(::pg_query::Node* view_query) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete view_query_;
  }
  if (view_query) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(view_query);
    if (message_arena != submessage_arena) {
      view_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, view_query, submessage_arena);
    }
    
  } else {
    
  }
  view_query_ = view_query;
  // @@protoc_insertion_point(field_set_allocated:pg_query.IntoClause.view_query)
}

// bool skip_data = 8 [json_name = "skipData"];
inline void IntoClause::clear_skip_data() {
  skip_data_ = false;
}
inline bool IntoClause::_internal_skip_data() const {
  return skip_data_;
}
inline bool IntoClause::skip_data() const {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.skip_data)
  return _internal_skip_data();
}
inline void IntoClause::_internal_set_skip_data(bool value) {
  
  skip_data_ = value;
}
inline void IntoClause::set_skip_data(bool value) {
  _internal_set_skip_data(value);
  // @@protoc_insertion_point(field_set:pg_query.IntoClause.skip_data)
}

// -------------------------------------------------------------------

// RawStmt

// .pg_query.Node stmt = 1 [json_name = "stmt"];
inline bool RawStmt::_internal_has_stmt() const {
  return this != internal_default_instance() && stmt_ != nullptr;
}
inline bool RawStmt::has_stmt() const {
  return _internal_has_stmt();
}
inline void RawStmt::clear_stmt() {
  if (GetArena() == nullptr && stmt_ != nullptr) {
    delete stmt_;
  }
  stmt_ = nullptr;
}
inline const ::pg_query::Node& RawStmt::_internal_stmt() const {
  const ::pg_query::Node* p = stmt_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RawStmt::stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.RawStmt.stmt)
  return _internal_stmt();
}
inline void RawStmt::unsafe_arena_set_allocated_stmt(
    ::pg_query::Node* stmt) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(stmt_);
  }
  stmt_ = stmt;
  if (stmt) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RawStmt.stmt)
}
inline ::pg_query::Node* RawStmt::release_stmt() {
  
  ::pg_query::Node* temp = stmt_;
  stmt_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RawStmt::unsafe_arena_release_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.RawStmt.stmt)
  
  ::pg_query::Node* temp = stmt_;
  stmt_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RawStmt::_internal_mutable_stmt() {
  
  if (stmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    stmt_ = p;
  }
  return stmt_;
}
inline ::pg_query::Node* RawStmt::mutable_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.RawStmt.stmt)
  return _internal_mutable_stmt();
}
inline void RawStmt::set_allocated_stmt(::pg_query::Node* stmt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete stmt_;
  }
  if (stmt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(stmt);
    if (message_arena != submessage_arena) {
      stmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, stmt, submessage_arena);
    }
    
  } else {
    
  }
  stmt_ = stmt;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RawStmt.stmt)
}

// int32 stmt_location = 2 [json_name = "stmt_location"];
inline void RawStmt::clear_stmt_location() {
  stmt_location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RawStmt::_internal_stmt_location() const {
  return stmt_location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RawStmt::stmt_location() const {
  // @@protoc_insertion_point(field_get:pg_query.RawStmt.stmt_location)
  return _internal_stmt_location();
}
inline void RawStmt::_internal_set_stmt_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  stmt_location_ = value;
}
inline void RawStmt::set_stmt_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_stmt_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RawStmt.stmt_location)
}

// int32 stmt_len = 3 [json_name = "stmt_len"];
inline void RawStmt::clear_stmt_len() {
  stmt_len_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RawStmt::_internal_stmt_len() const {
  return stmt_len_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RawStmt::stmt_len() const {
  // @@protoc_insertion_point(field_get:pg_query.RawStmt.stmt_len)
  return _internal_stmt_len();
}
inline void RawStmt::_internal_set_stmt_len(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  stmt_len_ = value;
}
inline void RawStmt::set_stmt_len(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_stmt_len(value);
  // @@protoc_insertion_point(field_set:pg_query.RawStmt.stmt_len)
}

// -------------------------------------------------------------------

// Query

// .pg_query.CmdType command_type = 1 [json_name = "commandType"];
inline void Query::clear_command_type() {
  command_type_ = 0;
}
inline ::pg_query::CmdType Query::_internal_command_type() const {
  return static_cast< ::pg_query::CmdType >(command_type_);
}
inline ::pg_query::CmdType Query::command_type() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.command_type)
  return _internal_command_type();
}
inline void Query::_internal_set_command_type(::pg_query::CmdType value) {
  
  command_type_ = value;
}
inline void Query::set_command_type(::pg_query::CmdType value) {
  _internal_set_command_type(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.command_type)
}

// .pg_query.QuerySource query_source = 2 [json_name = "querySource"];
inline void Query::clear_query_source() {
  query_source_ = 0;
}
inline ::pg_query::QuerySource Query::_internal_query_source() const {
  return static_cast< ::pg_query::QuerySource >(query_source_);
}
inline ::pg_query::QuerySource Query::query_source() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.query_source)
  return _internal_query_source();
}
inline void Query::_internal_set_query_source(::pg_query::QuerySource value) {
  
  query_source_ = value;
}
inline void Query::set_query_source(::pg_query::QuerySource value) {
  _internal_set_query_source(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.query_source)
}

// bool can_set_tag = 3 [json_name = "canSetTag"];
inline void Query::clear_can_set_tag() {
  can_set_tag_ = false;
}
inline bool Query::_internal_can_set_tag() const {
  return can_set_tag_;
}
inline bool Query::can_set_tag() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.can_set_tag)
  return _internal_can_set_tag();
}
inline void Query::_internal_set_can_set_tag(bool value) {
  
  can_set_tag_ = value;
}
inline void Query::set_can_set_tag(bool value) {
  _internal_set_can_set_tag(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.can_set_tag)
}

// .pg_query.Node utility_stmt = 4 [json_name = "utilityStmt"];
inline bool Query::_internal_has_utility_stmt() const {
  return this != internal_default_instance() && utility_stmt_ != nullptr;
}
inline bool Query::has_utility_stmt() const {
  return _internal_has_utility_stmt();
}
inline void Query::clear_utility_stmt() {
  if (GetArena() == nullptr && utility_stmt_ != nullptr) {
    delete utility_stmt_;
  }
  utility_stmt_ = nullptr;
}
inline const ::pg_query::Node& Query::_internal_utility_stmt() const {
  const ::pg_query::Node* p = utility_stmt_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Query::utility_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.utility_stmt)
  return _internal_utility_stmt();
}
inline void Query::unsafe_arena_set_allocated_utility_stmt(
    ::pg_query::Node* utility_stmt) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(utility_stmt_);
  }
  utility_stmt_ = utility_stmt;
  if (utility_stmt) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.utility_stmt)
}
inline ::pg_query::Node* Query::release_utility_stmt() {
  
  ::pg_query::Node* temp = utility_stmt_;
  utility_stmt_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* Query::unsafe_arena_release_utility_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Query.utility_stmt)
  
  ::pg_query::Node* temp = utility_stmt_;
  utility_stmt_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Query::_internal_mutable_utility_stmt() {
  
  if (utility_stmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    utility_stmt_ = p;
  }
  return utility_stmt_;
}
inline ::pg_query::Node* Query::mutable_utility_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.utility_stmt)
  return _internal_mutable_utility_stmt();
}
inline void Query::set_allocated_utility_stmt(::pg_query::Node* utility_stmt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete utility_stmt_;
  }
  if (utility_stmt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(utility_stmt);
    if (message_arena != submessage_arena) {
      utility_stmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, utility_stmt, submessage_arena);
    }
    
  } else {
    
  }
  utility_stmt_ = utility_stmt;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.utility_stmt)
}

// int32 result_relation = 5 [json_name = "resultRelation"];
inline void Query::clear_result_relation() {
  result_relation_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Query::_internal_result_relation() const {
  return result_relation_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Query::result_relation() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.result_relation)
  return _internal_result_relation();
}
inline void Query::_internal_set_result_relation(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  result_relation_ = value;
}
inline void Query::set_result_relation(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_result_relation(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.result_relation)
}

// bool has_aggs = 6 [json_name = "hasAggs"];
inline void Query::clear_has_aggs() {
  has_aggs_ = false;
}
inline bool Query::_internal_has_aggs() const {
  return has_aggs_;
}
inline bool Query::has_aggs() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.has_aggs)
  return _internal_has_aggs();
}
inline void Query::_internal_set_has_aggs(bool value) {
  
  has_aggs_ = value;
}
inline void Query::set_has_aggs(bool value) {
  _internal_set_has_aggs(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_aggs)
}

// bool has_window_funcs = 7 [json_name = "hasWindowFuncs"];
inline void Query::clear_has_window_funcs() {
  has_window_funcs_ = false;
}
inline bool Query::_internal_has_window_funcs() const {
  return has_window_funcs_;
}
inline bool Query::has_window_funcs() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.has_window_funcs)
  return _internal_has_window_funcs();
}
inline void Query::_internal_set_has_window_funcs(bool value) {
  
  has_window_funcs_ = value;
}
inline void Query::set_has_window_funcs(bool value) {
  _internal_set_has_window_funcs(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_window_funcs)
}

// bool has_target_srfs = 8 [json_name = "hasTargetSRFs"];
inline void Query::clear_has_target_srfs() {
  has_target_srfs_ = false;
}
inline bool Query::_internal_has_target_srfs() const {
  return has_target_srfs_;
}
inline bool Query::has_target_srfs() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.has_target_srfs)
  return _internal_has_target_srfs();
}
inline void Query::_internal_set_has_target_srfs(bool value) {
  
  has_target_srfs_ = value;
}
inline void Query::set_has_target_srfs(bool value) {
  _internal_set_has_target_srfs(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_target_srfs)
}

// bool has_sub_links = 9 [json_name = "hasSubLinks"];
inline void Query::clear_has_sub_links() {
  has_sub_links_ = false;
}
inline bool Query::_internal_has_sub_links() const {
  return has_sub_links_;
}
inline bool Query::has_sub_links() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.has_sub_links)
  return _internal_has_sub_links();
}
inline void Query::_internal_set_has_sub_links(bool value) {
  
  has_sub_links_ = value;
}
inline void Query::set_has_sub_links(bool value) {
  _internal_set_has_sub_links(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_sub_links)
}

// bool has_distinct_on = 10 [json_name = "hasDistinctOn"];
inline void Query::clear_has_distinct_on() {
  has_distinct_on_ = false;
}
inline bool Query::_internal_has_distinct_on() const {
  return has_distinct_on_;
}
inline bool Query::has_distinct_on() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.has_distinct_on)
  return _internal_has_distinct_on();
}
inline void Query::_internal_set_has_distinct_on(bool value) {
  
  has_distinct_on_ = value;
}
inline void Query::set_has_distinct_on(bool value) {
  _internal_set_has_distinct_on(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_distinct_on)
}

// bool has_recursive = 11 [json_name = "hasRecursive"];
inline void Query::clear_has_recursive() {
  has_recursive_ = false;
}
inline bool Query::_internal_has_recursive() const {
  return has_recursive_;
}
inline bool Query::has_recursive() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.has_recursive)
  return _internal_has_recursive();
}
inline void Query::_internal_set_has_recursive(bool value) {
  
  has_recursive_ = value;
}
inline void Query::set_has_recursive(bool value) {
  _internal_set_has_recursive(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_recursive)
}

// bool has_modifying_cte = 12 [json_name = "hasModifyingCTE"];
inline void Query::clear_has_modifying_cte() {
  has_modifying_cte_ = false;
}
inline bool Query::_internal_has_modifying_cte() const {
  return has_modifying_cte_;
}
inline bool Query::has_modifying_cte() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.has_modifying_cte)
  return _internal_has_modifying_cte();
}
inline void Query::_internal_set_has_modifying_cte(bool value) {
  
  has_modifying_cte_ = value;
}
inline void Query::set_has_modifying_cte(bool value) {
  _internal_set_has_modifying_cte(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_modifying_cte)
}

// bool has_for_update = 13 [json_name = "hasForUpdate"];
inline void Query::clear_has_for_update() {
  has_for_update_ = false;
}
inline bool Query::_internal_has_for_update() const {
  return has_for_update_;
}
inline bool Query::has_for_update() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.has_for_update)
  return _internal_has_for_update();
}
inline void Query::_internal_set_has_for_update(bool value) {
  
  has_for_update_ = value;
}
inline void Query::set_has_for_update(bool value) {
  _internal_set_has_for_update(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_for_update)
}

// bool has_row_security = 14 [json_name = "hasRowSecurity"];
inline void Query::clear_has_row_security() {
  has_row_security_ = false;
}
inline bool Query::_internal_has_row_security() const {
  return has_row_security_;
}
inline bool Query::has_row_security() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.has_row_security)
  return _internal_has_row_security();
}
inline void Query::_internal_set_has_row_security(bool value) {
  
  has_row_security_ = value;
}
inline void Query::set_has_row_security(bool value) {
  _internal_set_has_row_security(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_row_security)
}

// repeated .pg_query.Node cte_list = 15 [json_name = "cteList"];
inline int Query::_internal_cte_list_size() const {
  return cte_list_.size();
}
inline int Query::cte_list_size() const {
  return _internal_cte_list_size();
}
inline void Query::clear_cte_list() {
  cte_list_.Clear();
}
inline ::pg_query::Node* Query::mutable_cte_list(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.cte_list)
  return cte_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Query::mutable_cte_list() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.cte_list)
  return &cte_list_;
}
inline const ::pg_query::Node& Query::_internal_cte_list(int index) const {
  return cte_list_.Get(index);
}
inline const ::pg_query::Node& Query::cte_list(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Query.cte_list)
  return _internal_cte_list(index);
}
inline ::pg_query::Node* Query::_internal_add_cte_list() {
  return cte_list_.Add();
}
inline ::pg_query::Node* Query::add_cte_list() {
  // @@protoc_insertion_point(field_add:pg_query.Query.cte_list)
  return _internal_add_cte_list();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Query::cte_list() const {
  // @@protoc_insertion_point(field_list:pg_query.Query.cte_list)
  return cte_list_;
}

// repeated .pg_query.Node rtable = 16 [json_name = "rtable"];
inline int Query::_internal_rtable_size() const {
  return rtable_.size();
}
inline int Query::rtable_size() const {
  return _internal_rtable_size();
}
inline void Query::clear_rtable() {
  rtable_.Clear();
}
inline ::pg_query::Node* Query::mutable_rtable(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.rtable)
  return rtable_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Query::mutable_rtable() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.rtable)
  return &rtable_;
}
inline const ::pg_query::Node& Query::_internal_rtable(int index) const {
  return rtable_.Get(index);
}
inline const ::pg_query::Node& Query::rtable(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Query.rtable)
  return _internal_rtable(index);
}
inline ::pg_query::Node* Query::_internal_add_rtable() {
  return rtable_.Add();
}
inline ::pg_query::Node* Query::add_rtable() {
  // @@protoc_insertion_point(field_add:pg_query.Query.rtable)
  return _internal_add_rtable();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Query::rtable() const {
  // @@protoc_insertion_point(field_list:pg_query.Query.rtable)
  return rtable_;
}

// .pg_query.FromExpr jointree = 17 [json_name = "jointree"];
inline bool Query::_internal_has_jointree() const {
  return this != internal_default_instance() && jointree_ != nullptr;
}
inline bool Query::has_jointree() const {
  return _internal_has_jointree();
}
inline void Query::clear_jointree() {
  if (GetArena() == nullptr && jointree_ != nullptr) {
    delete jointree_;
  }
  jointree_ = nullptr;
}
inline const ::pg_query::FromExpr& Query::_internal_jointree() const {
  const ::pg_query::FromExpr* p = jointree_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::FromExpr&>(
      ::pg_query::_FromExpr_default_instance_);
}
inline const ::pg_query::FromExpr& Query::jointree() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.jointree)
  return _internal_jointree();
}
inline void Query::unsafe_arena_set_allocated_jointree(
    ::pg_query::FromExpr* jointree) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(jointree_);
  }
  jointree_ = jointree;
  if (jointree) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.jointree)
}
inline ::pg_query::FromExpr* Query::release_jointree() {
  
  ::pg_query::FromExpr* temp = jointree_;
  jointree_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::FromExpr* Query::unsafe_arena_release_jointree() {
  // @@protoc_insertion_point(field_release:pg_query.Query.jointree)
  
  ::pg_query::FromExpr* temp = jointree_;
  jointree_ = nullptr;
  return temp;
}
inline ::pg_query::FromExpr* Query::_internal_mutable_jointree() {
  
  if (jointree_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::FromExpr>(GetArena());
    jointree_ = p;
  }
  return jointree_;
}
inline ::pg_query::FromExpr* Query::mutable_jointree() {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.jointree)
  return _internal_mutable_jointree();
}
inline void Query::set_allocated_jointree(::pg_query::FromExpr* jointree) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete jointree_;
  }
  if (jointree) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(jointree);
    if (message_arena != submessage_arena) {
      jointree = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, jointree, submessage_arena);
    }
    
  } else {
    
  }
  jointree_ = jointree;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.jointree)
}

// repeated .pg_query.Node target_list = 18 [json_name = "targetList"];
inline int Query::_internal_target_list_size() const {
  return target_list_.size();
}
inline int Query::target_list_size() const {
  return _internal_target_list_size();
}
inline void Query::clear_target_list() {
  target_list_.Clear();
}
inline ::pg_query::Node* Query::mutable_target_list(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.target_list)
  return target_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Query::mutable_target_list() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.target_list)
  return &target_list_;
}
inline const ::pg_query::Node& Query::_internal_target_list(int index) const {
  return target_list_.Get(index);
}
inline const ::pg_query::Node& Query::target_list(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Query.target_list)
  return _internal_target_list(index);
}
inline ::pg_query::Node* Query::_internal_add_target_list() {
  return target_list_.Add();
}
inline ::pg_query::Node* Query::add_target_list() {
  // @@protoc_insertion_point(field_add:pg_query.Query.target_list)
  return _internal_add_target_list();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Query::target_list() const {
  // @@protoc_insertion_point(field_list:pg_query.Query.target_list)
  return target_list_;
}

// .pg_query.OverridingKind override = 19 [json_name = "override"];
inline void Query::clear_override() {
  override_ = 0;
}
inline ::pg_query::OverridingKind Query::_internal_override() const {
  return static_cast< ::pg_query::OverridingKind >(override_);
}
inline ::pg_query::OverridingKind Query::override() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.override)
  return _internal_override();
}
inline void Query::_internal_set_override(::pg_query::OverridingKind value) {
  
  override_ = value;
}
inline void Query::set_override(::pg_query::OverridingKind value) {
  _internal_set_override(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.override)
}

// .pg_query.OnConflictExpr on_conflict = 20 [json_name = "onConflict"];
inline bool Query::_internal_has_on_conflict() const {
  return this != internal_default_instance() && on_conflict_ != nullptr;
}
inline bool Query::has_on_conflict() const {
  return _internal_has_on_conflict();
}
inline void Query::clear_on_conflict() {
  if (GetArena() == nullptr && on_conflict_ != nullptr) {
    delete on_conflict_;
  }
  on_conflict_ = nullptr;
}
inline const ::pg_query::OnConflictExpr& Query::_internal_on_conflict() const {
  const ::pg_query::OnConflictExpr* p = on_conflict_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::OnConflictExpr&>(
      ::pg_query::_OnConflictExpr_default_instance_);
}
inline const ::pg_query::OnConflictExpr& Query::on_conflict() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.on_conflict)
  return _internal_on_conflict();
}
inline void Query::unsafe_arena_set_allocated_on_conflict(
    ::pg_query::OnConflictExpr* on_conflict) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(on_conflict_);
  }
  on_conflict_ = on_conflict;
  if (on_conflict) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.on_conflict)
}
inline ::pg_query::OnConflictExpr* Query::release_on_conflict() {
  
  ::pg_query::OnConflictExpr* temp = on_conflict_;
  on_conflict_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::OnConflictExpr* Query::unsafe_arena_release_on_conflict() {
  // @@protoc_insertion_point(field_release:pg_query.Query.on_conflict)
  
  ::pg_query::OnConflictExpr* temp = on_conflict_;
  on_conflict_ = nullptr;
  return temp;
}
inline ::pg_query::OnConflictExpr* Query::_internal_mutable_on_conflict() {
  
  if (on_conflict_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::OnConflictExpr>(GetArena());
    on_conflict_ = p;
  }
  return on_conflict_;
}
inline ::pg_query::OnConflictExpr* Query::mutable_on_conflict() {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.on_conflict)
  return _internal_mutable_on_conflict();
}
inline void Query::set_allocated_on_conflict(::pg_query::OnConflictExpr* on_conflict) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete on_conflict_;
  }
  if (on_conflict) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(on_conflict);
    if (message_arena != submessage_arena) {
      on_conflict = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, on_conflict, submessage_arena);
    }
    
  } else {
    
  }
  on_conflict_ = on_conflict;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.on_conflict)
}

// repeated .pg_query.Node returning_list = 21 [json_name = "returningList"];
inline int Query::_internal_returning_list_size() const {
  return returning_list_.size();
}
inline int Query::returning_list_size() const {
  return _internal_returning_list_size();
}
inline void Query::clear_returning_list() {
  returning_list_.Clear();
}
inline ::pg_query::Node* Query::mutable_returning_list(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.returning_list)
  return returning_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Query::mutable_returning_list() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.returning_list)
  return &returning_list_;
}
inline const ::pg_query::Node& Query::_internal_returning_list(int index) const {
  return returning_list_.Get(index);
}
inline const ::pg_query::Node& Query::returning_list(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Query.returning_list)
  return _internal_returning_list(index);
}
inline ::pg_query::Node* Query::_internal_add_returning_list() {
  return returning_list_.Add();
}
inline ::pg_query::Node* Query::add_returning_list() {
  // @@protoc_insertion_point(field_add:pg_query.Query.returning_list)
  return _internal_add_returning_list();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Query::returning_list() const {
  // @@protoc_insertion_point(field_list:pg_query.Query.returning_list)
  return returning_list_;
}

// repeated .pg_query.Node group_clause = 22 [json_name = "groupClause"];
inline int Query::_internal_group_clause_size() const {
  return group_clause_.size();
}
inline int Query::group_clause_size() const {
  return _internal_group_clause_size();
}
inline void Query::clear_group_clause() {
  group_clause_.Clear();
}
inline ::pg_query::Node* Query::mutable_group_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.group_clause)
  return group_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Query::mutable_group_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.group_clause)
  return &group_clause_;
}
inline const ::pg_query::Node& Query::_internal_group_clause(int index) const {
  return group_clause_.Get(index);
}
inline const ::pg_query::Node& Query::group_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Query.group_clause)
  return _internal_group_clause(index);
}
inline ::pg_query::Node* Query::_internal_add_group_clause() {
  return group_clause_.Add();
}
inline ::pg_query::Node* Query::add_group_clause() {
  // @@protoc_insertion_point(field_add:pg_query.Query.group_clause)
  return _internal_add_group_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Query::group_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.Query.group_clause)
  return group_clause_;
}

// repeated .pg_query.Node grouping_sets = 23 [json_name = "groupingSets"];
inline int Query::_internal_grouping_sets_size() const {
  return grouping_sets_.size();
}
inline int Query::grouping_sets_size() const {
  return _internal_grouping_sets_size();
}
inline void Query::clear_grouping_sets() {
  grouping_sets_.Clear();
}
inline ::pg_query::Node* Query::mutable_grouping_sets(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.grouping_sets)
  return grouping_sets_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Query::mutable_grouping_sets() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.grouping_sets)
  return &grouping_sets_;
}
inline const ::pg_query::Node& Query::_internal_grouping_sets(int index) const {
  return grouping_sets_.Get(index);
}
inline const ::pg_query::Node& Query::grouping_sets(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Query.grouping_sets)
  return _internal_grouping_sets(index);
}
inline ::pg_query::Node* Query::_internal_add_grouping_sets() {
  return grouping_sets_.Add();
}
inline ::pg_query::Node* Query::add_grouping_sets() {
  // @@protoc_insertion_point(field_add:pg_query.Query.grouping_sets)
  return _internal_add_grouping_sets();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Query::grouping_sets() const {
  // @@protoc_insertion_point(field_list:pg_query.Query.grouping_sets)
  return grouping_sets_;
}

// .pg_query.Node having_qual = 24 [json_name = "havingQual"];
inline bool Query::_internal_has_having_qual() const {
  return this != internal_default_instance() && having_qual_ != nullptr;
}
inline bool Query::has_having_qual() const {
  return _internal_has_having_qual();
}
inline void Query::clear_having_qual() {
  if (GetArena() == nullptr && having_qual_ != nullptr) {
    delete having_qual_;
  }
  having_qual_ = nullptr;
}
inline const ::pg_query::Node& Query::_internal_having_qual() const {
  const ::pg_query::Node* p = having_qual_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Query::having_qual() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.having_qual)
  return _internal_having_qual();
}
inline void Query::unsafe_arena_set_allocated_having_qual(
    ::pg_query::Node* having_qual) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(having_qual_);
  }
  having_qual_ = having_qual;
  if (having_qual) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.having_qual)
}
inline ::pg_query::Node* Query::release_having_qual() {
  
  ::pg_query::Node* temp = having_qual_;
  having_qual_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* Query::unsafe_arena_release_having_qual() {
  // @@protoc_insertion_point(field_release:pg_query.Query.having_qual)
  
  ::pg_query::Node* temp = having_qual_;
  having_qual_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Query::_internal_mutable_having_qual() {
  
  if (having_qual_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    having_qual_ = p;
  }
  return having_qual_;
}
inline ::pg_query::Node* Query::mutable_having_qual() {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.having_qual)
  return _internal_mutable_having_qual();
}
inline void Query::set_allocated_having_qual(::pg_query::Node* having_qual) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete having_qual_;
  }
  if (having_qual) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(having_qual);
    if (message_arena != submessage_arena) {
      having_qual = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, having_qual, submessage_arena);
    }
    
  } else {
    
  }
  having_qual_ = having_qual;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.having_qual)
}

// repeated .pg_query.Node window_clause = 25 [json_name = "windowClause"];
inline int Query::_internal_window_clause_size() const {
  return window_clause_.size();
}
inline int Query::window_clause_size() const {
  return _internal_window_clause_size();
}
inline void Query::clear_window_clause() {
  window_clause_.Clear();
}
inline ::pg_query::Node* Query::mutable_window_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.window_clause)
  return window_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Query::mutable_window_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.window_clause)
  return &window_clause_;
}
inline const ::pg_query::Node& Query::_internal_window_clause(int index) const {
  return window_clause_.Get(index);
}
inline const ::pg_query::Node& Query::window_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Query.window_clause)
  return _internal_window_clause(index);
}
inline ::pg_query::Node* Query::_internal_add_window_clause() {
  return window_clause_.Add();
}
inline ::pg_query::Node* Query::add_window_clause() {
  // @@protoc_insertion_point(field_add:pg_query.Query.window_clause)
  return _internal_add_window_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Query::window_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.Query.window_clause)
  return window_clause_;
}

// repeated .pg_query.Node distinct_clause = 26 [json_name = "distinctClause"];
inline int Query::_internal_distinct_clause_size() const {
  return distinct_clause_.size();
}
inline int Query::distinct_clause_size() const {
  return _internal_distinct_clause_size();
}
inline void Query::clear_distinct_clause() {
  distinct_clause_.Clear();
}
inline ::pg_query::Node* Query::mutable_distinct_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.distinct_clause)
  return distinct_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Query::mutable_distinct_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.distinct_clause)
  return &distinct_clause_;
}
inline const ::pg_query::Node& Query::_internal_distinct_clause(int index) const {
  return distinct_clause_.Get(index);
}
inline const ::pg_query::Node& Query::distinct_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Query.distinct_clause)
  return _internal_distinct_clause(index);
}
inline ::pg_query::Node* Query::_internal_add_distinct_clause() {
  return distinct_clause_.Add();
}
inline ::pg_query::Node* Query::add_distinct_clause() {
  // @@protoc_insertion_point(field_add:pg_query.Query.distinct_clause)
  return _internal_add_distinct_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Query::distinct_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.Query.distinct_clause)
  return distinct_clause_;
}

// repeated .pg_query.Node sort_clause = 27 [json_name = "sortClause"];
inline int Query::_internal_sort_clause_size() const {
  return sort_clause_.size();
}
inline int Query::sort_clause_size() const {
  return _internal_sort_clause_size();
}
inline void Query::clear_sort_clause() {
  sort_clause_.Clear();
}
inline ::pg_query::Node* Query::mutable_sort_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.sort_clause)
  return sort_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Query::mutable_sort_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.sort_clause)
  return &sort_clause_;
}
inline const ::pg_query::Node& Query::_internal_sort_clause(int index) const {
  return sort_clause_.Get(index);
}
inline const ::pg_query::Node& Query::sort_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Query.sort_clause)
  return _internal_sort_clause(index);
}
inline ::pg_query::Node* Query::_internal_add_sort_clause() {
  return sort_clause_.Add();
}
inline ::pg_query::Node* Query::add_sort_clause() {
  // @@protoc_insertion_point(field_add:pg_query.Query.sort_clause)
  return _internal_add_sort_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Query::sort_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.Query.sort_clause)
  return sort_clause_;
}

// .pg_query.Node limit_offset = 28 [json_name = "limitOffset"];
inline bool Query::_internal_has_limit_offset() const {
  return this != internal_default_instance() && limit_offset_ != nullptr;
}
inline bool Query::has_limit_offset() const {
  return _internal_has_limit_offset();
}
inline void Query::clear_limit_offset() {
  if (GetArena() == nullptr && limit_offset_ != nullptr) {
    delete limit_offset_;
  }
  limit_offset_ = nullptr;
}
inline const ::pg_query::Node& Query::_internal_limit_offset() const {
  const ::pg_query::Node* p = limit_offset_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Query::limit_offset() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.limit_offset)
  return _internal_limit_offset();
}
inline void Query::unsafe_arena_set_allocated_limit_offset(
    ::pg_query::Node* limit_offset) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(limit_offset_);
  }
  limit_offset_ = limit_offset;
  if (limit_offset) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.limit_offset)
}
inline ::pg_query::Node* Query::release_limit_offset() {
  
  ::pg_query::Node* temp = limit_offset_;
  limit_offset_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* Query::unsafe_arena_release_limit_offset() {
  // @@protoc_insertion_point(field_release:pg_query.Query.limit_offset)
  
  ::pg_query::Node* temp = limit_offset_;
  limit_offset_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Query::_internal_mutable_limit_offset() {
  
  if (limit_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    limit_offset_ = p;
  }
  return limit_offset_;
}
inline ::pg_query::Node* Query::mutable_limit_offset() {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.limit_offset)
  return _internal_mutable_limit_offset();
}
inline void Query::set_allocated_limit_offset(::pg_query::Node* limit_offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete limit_offset_;
  }
  if (limit_offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(limit_offset);
    if (message_arena != submessage_arena) {
      limit_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, limit_offset, submessage_arena);
    }
    
  } else {
    
  }
  limit_offset_ = limit_offset;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.limit_offset)
}

// .pg_query.Node limit_count = 29 [json_name = "limitCount"];
inline bool Query::_internal_has_limit_count() const {
  return this != internal_default_instance() && limit_count_ != nullptr;
}
inline bool Query::has_limit_count() const {
  return _internal_has_limit_count();
}
inline void Query::clear_limit_count() {
  if (GetArena() == nullptr && limit_count_ != nullptr) {
    delete limit_count_;
  }
  limit_count_ = nullptr;
}
inline const ::pg_query::Node& Query::_internal_limit_count() const {
  const ::pg_query::Node* p = limit_count_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Query::limit_count() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.limit_count)
  return _internal_limit_count();
}
inline void Query::unsafe_arena_set_allocated_limit_count(
    ::pg_query::Node* limit_count) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(limit_count_);
  }
  limit_count_ = limit_count;
  if (limit_count) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.limit_count)
}
inline ::pg_query::Node* Query::release_limit_count() {
  
  ::pg_query::Node* temp = limit_count_;
  limit_count_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* Query::unsafe_arena_release_limit_count() {
  // @@protoc_insertion_point(field_release:pg_query.Query.limit_count)
  
  ::pg_query::Node* temp = limit_count_;
  limit_count_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Query::_internal_mutable_limit_count() {
  
  if (limit_count_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    limit_count_ = p;
  }
  return limit_count_;
}
inline ::pg_query::Node* Query::mutable_limit_count() {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.limit_count)
  return _internal_mutable_limit_count();
}
inline void Query::set_allocated_limit_count(::pg_query::Node* limit_count) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete limit_count_;
  }
  if (limit_count) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(limit_count);
    if (message_arena != submessage_arena) {
      limit_count = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, limit_count, submessage_arena);
    }
    
  } else {
    
  }
  limit_count_ = limit_count;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.limit_count)
}

// .pg_query.LimitOption limit_option = 30 [json_name = "limitOption"];
inline void Query::clear_limit_option() {
  limit_option_ = 0;
}
inline ::pg_query::LimitOption Query::_internal_limit_option() const {
  return static_cast< ::pg_query::LimitOption >(limit_option_);
}
inline ::pg_query::LimitOption Query::limit_option() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.limit_option)
  return _internal_limit_option();
}
inline void Query::_internal_set_limit_option(::pg_query::LimitOption value) {
  
  limit_option_ = value;
}
inline void Query::set_limit_option(::pg_query::LimitOption value) {
  _internal_set_limit_option(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.limit_option)
}

// repeated .pg_query.Node row_marks = 31 [json_name = "rowMarks"];
inline int Query::_internal_row_marks_size() const {
  return row_marks_.size();
}
inline int Query::row_marks_size() const {
  return _internal_row_marks_size();
}
inline void Query::clear_row_marks() {
  row_marks_.Clear();
}
inline ::pg_query::Node* Query::mutable_row_marks(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.row_marks)
  return row_marks_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Query::mutable_row_marks() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.row_marks)
  return &row_marks_;
}
inline const ::pg_query::Node& Query::_internal_row_marks(int index) const {
  return row_marks_.Get(index);
}
inline const ::pg_query::Node& Query::row_marks(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Query.row_marks)
  return _internal_row_marks(index);
}
inline ::pg_query::Node* Query::_internal_add_row_marks() {
  return row_marks_.Add();
}
inline ::pg_query::Node* Query::add_row_marks() {
  // @@protoc_insertion_point(field_add:pg_query.Query.row_marks)
  return _internal_add_row_marks();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Query::row_marks() const {
  // @@protoc_insertion_point(field_list:pg_query.Query.row_marks)
  return row_marks_;
}

// .pg_query.Node set_operations = 32 [json_name = "setOperations"];
inline bool Query::_internal_has_set_operations() const {
  return this != internal_default_instance() && set_operations_ != nullptr;
}
inline bool Query::has_set_operations() const {
  return _internal_has_set_operations();
}
inline void Query::clear_set_operations() {
  if (GetArena() == nullptr && set_operations_ != nullptr) {
    delete set_operations_;
  }
  set_operations_ = nullptr;
}
inline const ::pg_query::Node& Query::_internal_set_operations() const {
  const ::pg_query::Node* p = set_operations_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Query::set_operations() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.set_operations)
  return _internal_set_operations();
}
inline void Query::unsafe_arena_set_allocated_set_operations(
    ::pg_query::Node* set_operations) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(set_operations_);
  }
  set_operations_ = set_operations;
  if (set_operations) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.set_operations)
}
inline ::pg_query::Node* Query::release_set_operations() {
  
  ::pg_query::Node* temp = set_operations_;
  set_operations_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* Query::unsafe_arena_release_set_operations() {
  // @@protoc_insertion_point(field_release:pg_query.Query.set_operations)
  
  ::pg_query::Node* temp = set_operations_;
  set_operations_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Query::_internal_mutable_set_operations() {
  
  if (set_operations_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    set_operations_ = p;
  }
  return set_operations_;
}
inline ::pg_query::Node* Query::mutable_set_operations() {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.set_operations)
  return _internal_mutable_set_operations();
}
inline void Query::set_allocated_set_operations(::pg_query::Node* set_operations) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete set_operations_;
  }
  if (set_operations) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(set_operations);
    if (message_arena != submessage_arena) {
      set_operations = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_operations, submessage_arena);
    }
    
  } else {
    
  }
  set_operations_ = set_operations;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.set_operations)
}

// repeated .pg_query.Node constraint_deps = 33 [json_name = "constraintDeps"];
inline int Query::_internal_constraint_deps_size() const {
  return constraint_deps_.size();
}
inline int Query::constraint_deps_size() const {
  return _internal_constraint_deps_size();
}
inline void Query::clear_constraint_deps() {
  constraint_deps_.Clear();
}
inline ::pg_query::Node* Query::mutable_constraint_deps(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.constraint_deps)
  return constraint_deps_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Query::mutable_constraint_deps() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.constraint_deps)
  return &constraint_deps_;
}
inline const ::pg_query::Node& Query::_internal_constraint_deps(int index) const {
  return constraint_deps_.Get(index);
}
inline const ::pg_query::Node& Query::constraint_deps(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Query.constraint_deps)
  return _internal_constraint_deps(index);
}
inline ::pg_query::Node* Query::_internal_add_constraint_deps() {
  return constraint_deps_.Add();
}
inline ::pg_query::Node* Query::add_constraint_deps() {
  // @@protoc_insertion_point(field_add:pg_query.Query.constraint_deps)
  return _internal_add_constraint_deps();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Query::constraint_deps() const {
  // @@protoc_insertion_point(field_list:pg_query.Query.constraint_deps)
  return constraint_deps_;
}

// repeated .pg_query.Node with_check_options = 34 [json_name = "withCheckOptions"];
inline int Query::_internal_with_check_options_size() const {
  return with_check_options_.size();
}
inline int Query::with_check_options_size() const {
  return _internal_with_check_options_size();
}
inline void Query::clear_with_check_options() {
  with_check_options_.Clear();
}
inline ::pg_query::Node* Query::mutable_with_check_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.with_check_options)
  return with_check_options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Query::mutable_with_check_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.with_check_options)
  return &with_check_options_;
}
inline const ::pg_query::Node& Query::_internal_with_check_options(int index) const {
  return with_check_options_.Get(index);
}
inline const ::pg_query::Node& Query::with_check_options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Query.with_check_options)
  return _internal_with_check_options(index);
}
inline ::pg_query::Node* Query::_internal_add_with_check_options() {
  return with_check_options_.Add();
}
inline ::pg_query::Node* Query::add_with_check_options() {
  // @@protoc_insertion_point(field_add:pg_query.Query.with_check_options)
  return _internal_add_with_check_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Query::with_check_options() const {
  // @@protoc_insertion_point(field_list:pg_query.Query.with_check_options)
  return with_check_options_;
}

// int32 stmt_location = 35 [json_name = "stmt_location"];
inline void Query::clear_stmt_location() {
  stmt_location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Query::_internal_stmt_location() const {
  return stmt_location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Query::stmt_location() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.stmt_location)
  return _internal_stmt_location();
}
inline void Query::_internal_set_stmt_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  stmt_location_ = value;
}
inline void Query::set_stmt_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_stmt_location(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.stmt_location)
}

// int32 stmt_len = 36 [json_name = "stmt_len"];
inline void Query::clear_stmt_len() {
  stmt_len_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Query::_internal_stmt_len() const {
  return stmt_len_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Query::stmt_len() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.stmt_len)
  return _internal_stmt_len();
}
inline void Query::_internal_set_stmt_len(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  stmt_len_ = value;
}
inline void Query::set_stmt_len(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_stmt_len(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.stmt_len)
}

// -------------------------------------------------------------------

// InsertStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool InsertStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool InsertStmt::has_relation() const {
  return _internal_has_relation();
}
inline void InsertStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& InsertStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& InsertStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.InsertStmt.relation)
  return _internal_relation();
}
inline void InsertStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InsertStmt.relation)
}
inline ::pg_query::RangeVar* InsertStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* InsertStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.InsertStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* InsertStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* InsertStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.relation)
  return _internal_mutable_relation();
}
inline void InsertStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.InsertStmt.relation)
}

// repeated .pg_query.Node cols = 2 [json_name = "cols"];
inline int InsertStmt::_internal_cols_size() const {
  return cols_.size();
}
inline int InsertStmt::cols_size() const {
  return _internal_cols_size();
}
inline void InsertStmt::clear_cols() {
  cols_.Clear();
}
inline ::pg_query::Node* InsertStmt::mutable_cols(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.cols)
  return cols_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
InsertStmt::mutable_cols() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.InsertStmt.cols)
  return &cols_;
}
inline const ::pg_query::Node& InsertStmt::_internal_cols(int index) const {
  return cols_.Get(index);
}
inline const ::pg_query::Node& InsertStmt::cols(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.InsertStmt.cols)
  return _internal_cols(index);
}
inline ::pg_query::Node* InsertStmt::_internal_add_cols() {
  return cols_.Add();
}
inline ::pg_query::Node* InsertStmt::add_cols() {
  // @@protoc_insertion_point(field_add:pg_query.InsertStmt.cols)
  return _internal_add_cols();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
InsertStmt::cols() const {
  // @@protoc_insertion_point(field_list:pg_query.InsertStmt.cols)
  return cols_;
}

// .pg_query.Node select_stmt = 3 [json_name = "selectStmt"];
inline bool InsertStmt::_internal_has_select_stmt() const {
  return this != internal_default_instance() && select_stmt_ != nullptr;
}
inline bool InsertStmt::has_select_stmt() const {
  return _internal_has_select_stmt();
}
inline void InsertStmt::clear_select_stmt() {
  if (GetArena() == nullptr && select_stmt_ != nullptr) {
    delete select_stmt_;
  }
  select_stmt_ = nullptr;
}
inline const ::pg_query::Node& InsertStmt::_internal_select_stmt() const {
  const ::pg_query::Node* p = select_stmt_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& InsertStmt::select_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.InsertStmt.select_stmt)
  return _internal_select_stmt();
}
inline void InsertStmt::unsafe_arena_set_allocated_select_stmt(
    ::pg_query::Node* select_stmt) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(select_stmt_);
  }
  select_stmt_ = select_stmt;
  if (select_stmt) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InsertStmt.select_stmt)
}
inline ::pg_query::Node* InsertStmt::release_select_stmt() {
  
  ::pg_query::Node* temp = select_stmt_;
  select_stmt_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* InsertStmt::unsafe_arena_release_select_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.InsertStmt.select_stmt)
  
  ::pg_query::Node* temp = select_stmt_;
  select_stmt_ = nullptr;
  return temp;
}
inline ::pg_query::Node* InsertStmt::_internal_mutable_select_stmt() {
  
  if (select_stmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    select_stmt_ = p;
  }
  return select_stmt_;
}
inline ::pg_query::Node* InsertStmt::mutable_select_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.select_stmt)
  return _internal_mutable_select_stmt();
}
inline void InsertStmt::set_allocated_select_stmt(::pg_query::Node* select_stmt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete select_stmt_;
  }
  if (select_stmt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(select_stmt);
    if (message_arena != submessage_arena) {
      select_stmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, select_stmt, submessage_arena);
    }
    
  } else {
    
  }
  select_stmt_ = select_stmt;
  // @@protoc_insertion_point(field_set_allocated:pg_query.InsertStmt.select_stmt)
}

// .pg_query.OnConflictClause on_conflict_clause = 4 [json_name = "onConflictClause"];
inline bool InsertStmt::_internal_has_on_conflict_clause() const {
  return this != internal_default_instance() && on_conflict_clause_ != nullptr;
}
inline bool InsertStmt::has_on_conflict_clause() const {
  return _internal_has_on_conflict_clause();
}
inline void InsertStmt::clear_on_conflict_clause() {
  if (GetArena() == nullptr && on_conflict_clause_ != nullptr) {
    delete on_conflict_clause_;
  }
  on_conflict_clause_ = nullptr;
}
inline const ::pg_query::OnConflictClause& InsertStmt::_internal_on_conflict_clause() const {
  const ::pg_query::OnConflictClause* p = on_conflict_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::OnConflictClause&>(
      ::pg_query::_OnConflictClause_default_instance_);
}
inline const ::pg_query::OnConflictClause& InsertStmt::on_conflict_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.InsertStmt.on_conflict_clause)
  return _internal_on_conflict_clause();
}
inline void InsertStmt::unsafe_arena_set_allocated_on_conflict_clause(
    ::pg_query::OnConflictClause* on_conflict_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(on_conflict_clause_);
  }
  on_conflict_clause_ = on_conflict_clause;
  if (on_conflict_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InsertStmt.on_conflict_clause)
}
inline ::pg_query::OnConflictClause* InsertStmt::release_on_conflict_clause() {
  
  ::pg_query::OnConflictClause* temp = on_conflict_clause_;
  on_conflict_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::OnConflictClause* InsertStmt::unsafe_arena_release_on_conflict_clause() {
  // @@protoc_insertion_point(field_release:pg_query.InsertStmt.on_conflict_clause)
  
  ::pg_query::OnConflictClause* temp = on_conflict_clause_;
  on_conflict_clause_ = nullptr;
  return temp;
}
inline ::pg_query::OnConflictClause* InsertStmt::_internal_mutable_on_conflict_clause() {
  
  if (on_conflict_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::OnConflictClause>(GetArena());
    on_conflict_clause_ = p;
  }
  return on_conflict_clause_;
}
inline ::pg_query::OnConflictClause* InsertStmt::mutable_on_conflict_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.on_conflict_clause)
  return _internal_mutable_on_conflict_clause();
}
inline void InsertStmt::set_allocated_on_conflict_clause(::pg_query::OnConflictClause* on_conflict_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete on_conflict_clause_;
  }
  if (on_conflict_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(on_conflict_clause);
    if (message_arena != submessage_arena) {
      on_conflict_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, on_conflict_clause, submessage_arena);
    }
    
  } else {
    
  }
  on_conflict_clause_ = on_conflict_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.InsertStmt.on_conflict_clause)
}

// repeated .pg_query.Node returning_list = 5 [json_name = "returningList"];
inline int InsertStmt::_internal_returning_list_size() const {
  return returning_list_.size();
}
inline int InsertStmt::returning_list_size() const {
  return _internal_returning_list_size();
}
inline void InsertStmt::clear_returning_list() {
  returning_list_.Clear();
}
inline ::pg_query::Node* InsertStmt::mutable_returning_list(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.returning_list)
  return returning_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
InsertStmt::mutable_returning_list() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.InsertStmt.returning_list)
  return &returning_list_;
}
inline const ::pg_query::Node& InsertStmt::_internal_returning_list(int index) const {
  return returning_list_.Get(index);
}
inline const ::pg_query::Node& InsertStmt::returning_list(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.InsertStmt.returning_list)
  return _internal_returning_list(index);
}
inline ::pg_query::Node* InsertStmt::_internal_add_returning_list() {
  return returning_list_.Add();
}
inline ::pg_query::Node* InsertStmt::add_returning_list() {
  // @@protoc_insertion_point(field_add:pg_query.InsertStmt.returning_list)
  return _internal_add_returning_list();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
InsertStmt::returning_list() const {
  // @@protoc_insertion_point(field_list:pg_query.InsertStmt.returning_list)
  return returning_list_;
}

// .pg_query.WithClause with_clause = 6 [json_name = "withClause"];
inline bool InsertStmt::_internal_has_with_clause() const {
  return this != internal_default_instance() && with_clause_ != nullptr;
}
inline bool InsertStmt::has_with_clause() const {
  return _internal_has_with_clause();
}
inline void InsertStmt::clear_with_clause() {
  if (GetArena() == nullptr && with_clause_ != nullptr) {
    delete with_clause_;
  }
  with_clause_ = nullptr;
}
inline const ::pg_query::WithClause& InsertStmt::_internal_with_clause() const {
  const ::pg_query::WithClause* p = with_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::WithClause&>(
      ::pg_query::_WithClause_default_instance_);
}
inline const ::pg_query::WithClause& InsertStmt::with_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.InsertStmt.with_clause)
  return _internal_with_clause();
}
inline void InsertStmt::unsafe_arena_set_allocated_with_clause(
    ::pg_query::WithClause* with_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(with_clause_);
  }
  with_clause_ = with_clause;
  if (with_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InsertStmt.with_clause)
}
inline ::pg_query::WithClause* InsertStmt::release_with_clause() {
  
  ::pg_query::WithClause* temp = with_clause_;
  with_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::WithClause* InsertStmt::unsafe_arena_release_with_clause() {
  // @@protoc_insertion_point(field_release:pg_query.InsertStmt.with_clause)
  
  ::pg_query::WithClause* temp = with_clause_;
  with_clause_ = nullptr;
  return temp;
}
inline ::pg_query::WithClause* InsertStmt::_internal_mutable_with_clause() {
  
  if (with_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArena());
    with_clause_ = p;
  }
  return with_clause_;
}
inline ::pg_query::WithClause* InsertStmt::mutable_with_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.with_clause)
  return _internal_mutable_with_clause();
}
inline void InsertStmt::set_allocated_with_clause(::pg_query::WithClause* with_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete with_clause_;
  }
  if (with_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(with_clause);
    if (message_arena != submessage_arena) {
      with_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, with_clause, submessage_arena);
    }
    
  } else {
    
  }
  with_clause_ = with_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.InsertStmt.with_clause)
}

// .pg_query.OverridingKind override = 7 [json_name = "override"];
inline void InsertStmt::clear_override() {
  override_ = 0;
}
inline ::pg_query::OverridingKind InsertStmt::_internal_override() const {
  return static_cast< ::pg_query::OverridingKind >(override_);
}
inline ::pg_query::OverridingKind InsertStmt::override() const {
  // @@protoc_insertion_point(field_get:pg_query.InsertStmt.override)
  return _internal_override();
}
inline void InsertStmt::_internal_set_override(::pg_query::OverridingKind value) {
  
  override_ = value;
}
inline void InsertStmt::set_override(::pg_query::OverridingKind value) {
  _internal_set_override(value);
  // @@protoc_insertion_point(field_set:pg_query.InsertStmt.override)
}

// -------------------------------------------------------------------

// DeleteStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool DeleteStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool DeleteStmt::has_relation() const {
  return _internal_has_relation();
}
inline void DeleteStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& DeleteStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& DeleteStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.DeleteStmt.relation)
  return _internal_relation();
}
inline void DeleteStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DeleteStmt.relation)
}
inline ::pg_query::RangeVar* DeleteStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* DeleteStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.DeleteStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* DeleteStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* DeleteStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.DeleteStmt.relation)
  return _internal_mutable_relation();
}
inline void DeleteStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.DeleteStmt.relation)
}

// repeated .pg_query.Node using_clause = 2 [json_name = "usingClause"];
inline int DeleteStmt::_internal_using_clause_size() const {
  return using_clause_.size();
}
inline int DeleteStmt::using_clause_size() const {
  return _internal_using_clause_size();
}
inline void DeleteStmt::clear_using_clause() {
  using_clause_.Clear();
}
inline ::pg_query::Node* DeleteStmt::mutable_using_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.DeleteStmt.using_clause)
  return using_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
DeleteStmt::mutable_using_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DeleteStmt.using_clause)
  return &using_clause_;
}
inline const ::pg_query::Node& DeleteStmt::_internal_using_clause(int index) const {
  return using_clause_.Get(index);
}
inline const ::pg_query::Node& DeleteStmt::using_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.DeleteStmt.using_clause)
  return _internal_using_clause(index);
}
inline ::pg_query::Node* DeleteStmt::_internal_add_using_clause() {
  return using_clause_.Add();
}
inline ::pg_query::Node* DeleteStmt::add_using_clause() {
  // @@protoc_insertion_point(field_add:pg_query.DeleteStmt.using_clause)
  return _internal_add_using_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
DeleteStmt::using_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.DeleteStmt.using_clause)
  return using_clause_;
}

// .pg_query.Node where_clause = 3 [json_name = "whereClause"];
inline bool DeleteStmt::_internal_has_where_clause() const {
  return this != internal_default_instance() && where_clause_ != nullptr;
}
inline bool DeleteStmt::has_where_clause() const {
  return _internal_has_where_clause();
}
inline void DeleteStmt::clear_where_clause() {
  if (GetArena() == nullptr && where_clause_ != nullptr) {
    delete where_clause_;
  }
  where_clause_ = nullptr;
}
inline const ::pg_query::Node& DeleteStmt::_internal_where_clause() const {
  const ::pg_query::Node* p = where_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& DeleteStmt::where_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.DeleteStmt.where_clause)
  return _internal_where_clause();
}
inline void DeleteStmt::unsafe_arena_set_allocated_where_clause(
    ::pg_query::Node* where_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(where_clause_);
  }
  where_clause_ = where_clause;
  if (where_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DeleteStmt.where_clause)
}
inline ::pg_query::Node* DeleteStmt::release_where_clause() {
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* DeleteStmt::unsafe_arena_release_where_clause() {
  // @@protoc_insertion_point(field_release:pg_query.DeleteStmt.where_clause)
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* DeleteStmt::_internal_mutable_where_clause() {
  
  if (where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    where_clause_ = p;
  }
  return where_clause_;
}
inline ::pg_query::Node* DeleteStmt::mutable_where_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.DeleteStmt.where_clause)
  return _internal_mutable_where_clause();
}
inline void DeleteStmt::set_allocated_where_clause(::pg_query::Node* where_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete where_clause_;
  }
  if (where_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(where_clause);
    if (message_arena != submessage_arena) {
      where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, where_clause, submessage_arena);
    }
    
  } else {
    
  }
  where_clause_ = where_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.DeleteStmt.where_clause)
}

// repeated .pg_query.Node returning_list = 4 [json_name = "returningList"];
inline int DeleteStmt::_internal_returning_list_size() const {
  return returning_list_.size();
}
inline int DeleteStmt::returning_list_size() const {
  return _internal_returning_list_size();
}
inline void DeleteStmt::clear_returning_list() {
  returning_list_.Clear();
}
inline ::pg_query::Node* DeleteStmt::mutable_returning_list(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.DeleteStmt.returning_list)
  return returning_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
DeleteStmt::mutable_returning_list() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DeleteStmt.returning_list)
  return &returning_list_;
}
inline const ::pg_query::Node& DeleteStmt::_internal_returning_list(int index) const {
  return returning_list_.Get(index);
}
inline const ::pg_query::Node& DeleteStmt::returning_list(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.DeleteStmt.returning_list)
  return _internal_returning_list(index);
}
inline ::pg_query::Node* DeleteStmt::_internal_add_returning_list() {
  return returning_list_.Add();
}
inline ::pg_query::Node* DeleteStmt::add_returning_list() {
  // @@protoc_insertion_point(field_add:pg_query.DeleteStmt.returning_list)
  return _internal_add_returning_list();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
DeleteStmt::returning_list() const {
  // @@protoc_insertion_point(field_list:pg_query.DeleteStmt.returning_list)
  return returning_list_;
}

// .pg_query.WithClause with_clause = 5 [json_name = "withClause"];
inline bool DeleteStmt::_internal_has_with_clause() const {
  return this != internal_default_instance() && with_clause_ != nullptr;
}
inline bool DeleteStmt::has_with_clause() const {
  return _internal_has_with_clause();
}
inline void DeleteStmt::clear_with_clause() {
  if (GetArena() == nullptr && with_clause_ != nullptr) {
    delete with_clause_;
  }
  with_clause_ = nullptr;
}
inline const ::pg_query::WithClause& DeleteStmt::_internal_with_clause() const {
  const ::pg_query::WithClause* p = with_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::WithClause&>(
      ::pg_query::_WithClause_default_instance_);
}
inline const ::pg_query::WithClause& DeleteStmt::with_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.DeleteStmt.with_clause)
  return _internal_with_clause();
}
inline void DeleteStmt::unsafe_arena_set_allocated_with_clause(
    ::pg_query::WithClause* with_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(with_clause_);
  }
  with_clause_ = with_clause;
  if (with_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DeleteStmt.with_clause)
}
inline ::pg_query::WithClause* DeleteStmt::release_with_clause() {
  
  ::pg_query::WithClause* temp = with_clause_;
  with_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::WithClause* DeleteStmt::unsafe_arena_release_with_clause() {
  // @@protoc_insertion_point(field_release:pg_query.DeleteStmt.with_clause)
  
  ::pg_query::WithClause* temp = with_clause_;
  with_clause_ = nullptr;
  return temp;
}
inline ::pg_query::WithClause* DeleteStmt::_internal_mutable_with_clause() {
  
  if (with_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArena());
    with_clause_ = p;
  }
  return with_clause_;
}
inline ::pg_query::WithClause* DeleteStmt::mutable_with_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.DeleteStmt.with_clause)
  return _internal_mutable_with_clause();
}
inline void DeleteStmt::set_allocated_with_clause(::pg_query::WithClause* with_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete with_clause_;
  }
  if (with_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(with_clause);
    if (message_arena != submessage_arena) {
      with_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, with_clause, submessage_arena);
    }
    
  } else {
    
  }
  with_clause_ = with_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.DeleteStmt.with_clause)
}

// -------------------------------------------------------------------

// UpdateStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool UpdateStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool UpdateStmt::has_relation() const {
  return _internal_has_relation();
}
inline void UpdateStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& UpdateStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& UpdateStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.relation)
  return _internal_relation();
}
inline void UpdateStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.UpdateStmt.relation)
}
inline ::pg_query::RangeVar* UpdateStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* UpdateStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.UpdateStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* UpdateStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* UpdateStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.relation)
  return _internal_mutable_relation();
}
inline void UpdateStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.UpdateStmt.relation)
}

// repeated .pg_query.Node target_list = 2 [json_name = "targetList"];
inline int UpdateStmt::_internal_target_list_size() const {
  return target_list_.size();
}
inline int UpdateStmt::target_list_size() const {
  return _internal_target_list_size();
}
inline void UpdateStmt::clear_target_list() {
  target_list_.Clear();
}
inline ::pg_query::Node* UpdateStmt::mutable_target_list(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.target_list)
  return target_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
UpdateStmt::mutable_target_list() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.UpdateStmt.target_list)
  return &target_list_;
}
inline const ::pg_query::Node& UpdateStmt::_internal_target_list(int index) const {
  return target_list_.Get(index);
}
inline const ::pg_query::Node& UpdateStmt::target_list(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.target_list)
  return _internal_target_list(index);
}
inline ::pg_query::Node* UpdateStmt::_internal_add_target_list() {
  return target_list_.Add();
}
inline ::pg_query::Node* UpdateStmt::add_target_list() {
  // @@protoc_insertion_point(field_add:pg_query.UpdateStmt.target_list)
  return _internal_add_target_list();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
UpdateStmt::target_list() const {
  // @@protoc_insertion_point(field_list:pg_query.UpdateStmt.target_list)
  return target_list_;
}

// .pg_query.Node where_clause = 3 [json_name = "whereClause"];
inline bool UpdateStmt::_internal_has_where_clause() const {
  return this != internal_default_instance() && where_clause_ != nullptr;
}
inline bool UpdateStmt::has_where_clause() const {
  return _internal_has_where_clause();
}
inline void UpdateStmt::clear_where_clause() {
  if (GetArena() == nullptr && where_clause_ != nullptr) {
    delete where_clause_;
  }
  where_clause_ = nullptr;
}
inline const ::pg_query::Node& UpdateStmt::_internal_where_clause() const {
  const ::pg_query::Node* p = where_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& UpdateStmt::where_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.where_clause)
  return _internal_where_clause();
}
inline void UpdateStmt::unsafe_arena_set_allocated_where_clause(
    ::pg_query::Node* where_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(where_clause_);
  }
  where_clause_ = where_clause;
  if (where_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.UpdateStmt.where_clause)
}
inline ::pg_query::Node* UpdateStmt::release_where_clause() {
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* UpdateStmt::unsafe_arena_release_where_clause() {
  // @@protoc_insertion_point(field_release:pg_query.UpdateStmt.where_clause)
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* UpdateStmt::_internal_mutable_where_clause() {
  
  if (where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    where_clause_ = p;
  }
  return where_clause_;
}
inline ::pg_query::Node* UpdateStmt::mutable_where_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.where_clause)
  return _internal_mutable_where_clause();
}
inline void UpdateStmt::set_allocated_where_clause(::pg_query::Node* where_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete where_clause_;
  }
  if (where_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(where_clause);
    if (message_arena != submessage_arena) {
      where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, where_clause, submessage_arena);
    }
    
  } else {
    
  }
  where_clause_ = where_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.UpdateStmt.where_clause)
}

// repeated .pg_query.Node from_clause = 4 [json_name = "fromClause"];
inline int UpdateStmt::_internal_from_clause_size() const {
  return from_clause_.size();
}
inline int UpdateStmt::from_clause_size() const {
  return _internal_from_clause_size();
}
inline void UpdateStmt::clear_from_clause() {
  from_clause_.Clear();
}
inline ::pg_query::Node* UpdateStmt::mutable_from_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.from_clause)
  return from_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
UpdateStmt::mutable_from_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.UpdateStmt.from_clause)
  return &from_clause_;
}
inline const ::pg_query::Node& UpdateStmt::_internal_from_clause(int index) const {
  return from_clause_.Get(index);
}
inline const ::pg_query::Node& UpdateStmt::from_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.from_clause)
  return _internal_from_clause(index);
}
inline ::pg_query::Node* UpdateStmt::_internal_add_from_clause() {
  return from_clause_.Add();
}
inline ::pg_query::Node* UpdateStmt::add_from_clause() {
  // @@protoc_insertion_point(field_add:pg_query.UpdateStmt.from_clause)
  return _internal_add_from_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
UpdateStmt::from_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.UpdateStmt.from_clause)
  return from_clause_;
}

// repeated .pg_query.Node returning_list = 5 [json_name = "returningList"];
inline int UpdateStmt::_internal_returning_list_size() const {
  return returning_list_.size();
}
inline int UpdateStmt::returning_list_size() const {
  return _internal_returning_list_size();
}
inline void UpdateStmt::clear_returning_list() {
  returning_list_.Clear();
}
inline ::pg_query::Node* UpdateStmt::mutable_returning_list(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.returning_list)
  return returning_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
UpdateStmt::mutable_returning_list() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.UpdateStmt.returning_list)
  return &returning_list_;
}
inline const ::pg_query::Node& UpdateStmt::_internal_returning_list(int index) const {
  return returning_list_.Get(index);
}
inline const ::pg_query::Node& UpdateStmt::returning_list(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.returning_list)
  return _internal_returning_list(index);
}
inline ::pg_query::Node* UpdateStmt::_internal_add_returning_list() {
  return returning_list_.Add();
}
inline ::pg_query::Node* UpdateStmt::add_returning_list() {
  // @@protoc_insertion_point(field_add:pg_query.UpdateStmt.returning_list)
  return _internal_add_returning_list();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
UpdateStmt::returning_list() const {
  // @@protoc_insertion_point(field_list:pg_query.UpdateStmt.returning_list)
  return returning_list_;
}

// .pg_query.WithClause with_clause = 6 [json_name = "withClause"];
inline bool UpdateStmt::_internal_has_with_clause() const {
  return this != internal_default_instance() && with_clause_ != nullptr;
}
inline bool UpdateStmt::has_with_clause() const {
  return _internal_has_with_clause();
}
inline void UpdateStmt::clear_with_clause() {
  if (GetArena() == nullptr && with_clause_ != nullptr) {
    delete with_clause_;
  }
  with_clause_ = nullptr;
}
inline const ::pg_query::WithClause& UpdateStmt::_internal_with_clause() const {
  const ::pg_query::WithClause* p = with_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::WithClause&>(
      ::pg_query::_WithClause_default_instance_);
}
inline const ::pg_query::WithClause& UpdateStmt::with_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.with_clause)
  return _internal_with_clause();
}
inline void UpdateStmt::unsafe_arena_set_allocated_with_clause(
    ::pg_query::WithClause* with_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(with_clause_);
  }
  with_clause_ = with_clause;
  if (with_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.UpdateStmt.with_clause)
}
inline ::pg_query::WithClause* UpdateStmt::release_with_clause() {
  
  ::pg_query::WithClause* temp = with_clause_;
  with_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::WithClause* UpdateStmt::unsafe_arena_release_with_clause() {
  // @@protoc_insertion_point(field_release:pg_query.UpdateStmt.with_clause)
  
  ::pg_query::WithClause* temp = with_clause_;
  with_clause_ = nullptr;
  return temp;
}
inline ::pg_query::WithClause* UpdateStmt::_internal_mutable_with_clause() {
  
  if (with_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArena());
    with_clause_ = p;
  }
  return with_clause_;
}
inline ::pg_query::WithClause* UpdateStmt::mutable_with_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.with_clause)
  return _internal_mutable_with_clause();
}
inline void UpdateStmt::set_allocated_with_clause(::pg_query::WithClause* with_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete with_clause_;
  }
  if (with_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(with_clause);
    if (message_arena != submessage_arena) {
      with_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, with_clause, submessage_arena);
    }
    
  } else {
    
  }
  with_clause_ = with_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.UpdateStmt.with_clause)
}

// -------------------------------------------------------------------

// SelectStmt

// repeated .pg_query.Node distinct_clause = 1 [json_name = "distinctClause"];
inline int SelectStmt::_internal_distinct_clause_size() const {
  return distinct_clause_.size();
}
inline int SelectStmt::distinct_clause_size() const {
  return _internal_distinct_clause_size();
}
inline void SelectStmt::clear_distinct_clause() {
  distinct_clause_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_distinct_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.distinct_clause)
  return distinct_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SelectStmt::mutable_distinct_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.distinct_clause)
  return &distinct_clause_;
}
inline const ::pg_query::Node& SelectStmt::_internal_distinct_clause(int index) const {
  return distinct_clause_.Get(index);
}
inline const ::pg_query::Node& SelectStmt::distinct_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.distinct_clause)
  return _internal_distinct_clause(index);
}
inline ::pg_query::Node* SelectStmt::_internal_add_distinct_clause() {
  return distinct_clause_.Add();
}
inline ::pg_query::Node* SelectStmt::add_distinct_clause() {
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.distinct_clause)
  return _internal_add_distinct_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SelectStmt::distinct_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.distinct_clause)
  return distinct_clause_;
}

// .pg_query.IntoClause into_clause = 2 [json_name = "intoClause"];
inline bool SelectStmt::_internal_has_into_clause() const {
  return this != internal_default_instance() && into_clause_ != nullptr;
}
inline bool SelectStmt::has_into_clause() const {
  return _internal_has_into_clause();
}
inline void SelectStmt::clear_into_clause() {
  if (GetArena() == nullptr && into_clause_ != nullptr) {
    delete into_clause_;
  }
  into_clause_ = nullptr;
}
inline const ::pg_query::IntoClause& SelectStmt::_internal_into_clause() const {
  const ::pg_query::IntoClause* p = into_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::IntoClause&>(
      ::pg_query::_IntoClause_default_instance_);
}
inline const ::pg_query::IntoClause& SelectStmt::into_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.into_clause)
  return _internal_into_clause();
}
inline void SelectStmt::unsafe_arena_set_allocated_into_clause(
    ::pg_query::IntoClause* into_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(into_clause_);
  }
  into_clause_ = into_clause;
  if (into_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.into_clause)
}
inline ::pg_query::IntoClause* SelectStmt::release_into_clause() {
  
  ::pg_query::IntoClause* temp = into_clause_;
  into_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::IntoClause* SelectStmt::unsafe_arena_release_into_clause() {
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.into_clause)
  
  ::pg_query::IntoClause* temp = into_clause_;
  into_clause_ = nullptr;
  return temp;
}
inline ::pg_query::IntoClause* SelectStmt::_internal_mutable_into_clause() {
  
  if (into_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::IntoClause>(GetArena());
    into_clause_ = p;
  }
  return into_clause_;
}
inline ::pg_query::IntoClause* SelectStmt::mutable_into_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.into_clause)
  return _internal_mutable_into_clause();
}
inline void SelectStmt::set_allocated_into_clause(::pg_query::IntoClause* into_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete into_clause_;
  }
  if (into_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(into_clause);
    if (message_arena != submessage_arena) {
      into_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, into_clause, submessage_arena);
    }
    
  } else {
    
  }
  into_clause_ = into_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.into_clause)
}

// repeated .pg_query.Node target_list = 3 [json_name = "targetList"];
inline int SelectStmt::_internal_target_list_size() const {
  return target_list_.size();
}
inline int SelectStmt::target_list_size() const {
  return _internal_target_list_size();
}
inline void SelectStmt::clear_target_list() {
  target_list_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_target_list(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.target_list)
  return target_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SelectStmt::mutable_target_list() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.target_list)
  return &target_list_;
}
inline const ::pg_query::Node& SelectStmt::_internal_target_list(int index) const {
  return target_list_.Get(index);
}
inline const ::pg_query::Node& SelectStmt::target_list(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.target_list)
  return _internal_target_list(index);
}
inline ::pg_query::Node* SelectStmt::_internal_add_target_list() {
  return target_list_.Add();
}
inline ::pg_query::Node* SelectStmt::add_target_list() {
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.target_list)
  return _internal_add_target_list();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SelectStmt::target_list() const {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.target_list)
  return target_list_;
}

// repeated .pg_query.Node from_clause = 4 [json_name = "fromClause"];
inline int SelectStmt::_internal_from_clause_size() const {
  return from_clause_.size();
}
inline int SelectStmt::from_clause_size() const {
  return _internal_from_clause_size();
}
inline void SelectStmt::clear_from_clause() {
  from_clause_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_from_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.from_clause)
  return from_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SelectStmt::mutable_from_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.from_clause)
  return &from_clause_;
}
inline const ::pg_query::Node& SelectStmt::_internal_from_clause(int index) const {
  return from_clause_.Get(index);
}
inline const ::pg_query::Node& SelectStmt::from_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.from_clause)
  return _internal_from_clause(index);
}
inline ::pg_query::Node* SelectStmt::_internal_add_from_clause() {
  return from_clause_.Add();
}
inline ::pg_query::Node* SelectStmt::add_from_clause() {
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.from_clause)
  return _internal_add_from_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SelectStmt::from_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.from_clause)
  return from_clause_;
}

// .pg_query.Node where_clause = 5 [json_name = "whereClause"];
inline bool SelectStmt::_internal_has_where_clause() const {
  return this != internal_default_instance() && where_clause_ != nullptr;
}
inline bool SelectStmt::has_where_clause() const {
  return _internal_has_where_clause();
}
inline void SelectStmt::clear_where_clause() {
  if (GetArena() == nullptr && where_clause_ != nullptr) {
    delete where_clause_;
  }
  where_clause_ = nullptr;
}
inline const ::pg_query::Node& SelectStmt::_internal_where_clause() const {
  const ::pg_query::Node* p = where_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SelectStmt::where_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.where_clause)
  return _internal_where_clause();
}
inline void SelectStmt::unsafe_arena_set_allocated_where_clause(
    ::pg_query::Node* where_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(where_clause_);
  }
  where_clause_ = where_clause;
  if (where_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.where_clause)
}
inline ::pg_query::Node* SelectStmt::release_where_clause() {
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SelectStmt::unsafe_arena_release_where_clause() {
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.where_clause)
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SelectStmt::_internal_mutable_where_clause() {
  
  if (where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    where_clause_ = p;
  }
  return where_clause_;
}
inline ::pg_query::Node* SelectStmt::mutable_where_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.where_clause)
  return _internal_mutable_where_clause();
}
inline void SelectStmt::set_allocated_where_clause(::pg_query::Node* where_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete where_clause_;
  }
  if (where_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(where_clause);
    if (message_arena != submessage_arena) {
      where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, where_clause, submessage_arena);
    }
    
  } else {
    
  }
  where_clause_ = where_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.where_clause)
}

// repeated .pg_query.Node group_clause = 6 [json_name = "groupClause"];
inline int SelectStmt::_internal_group_clause_size() const {
  return group_clause_.size();
}
inline int SelectStmt::group_clause_size() const {
  return _internal_group_clause_size();
}
inline void SelectStmt::clear_group_clause() {
  group_clause_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_group_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.group_clause)
  return group_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SelectStmt::mutable_group_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.group_clause)
  return &group_clause_;
}
inline const ::pg_query::Node& SelectStmt::_internal_group_clause(int index) const {
  return group_clause_.Get(index);
}
inline const ::pg_query::Node& SelectStmt::group_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.group_clause)
  return _internal_group_clause(index);
}
inline ::pg_query::Node* SelectStmt::_internal_add_group_clause() {
  return group_clause_.Add();
}
inline ::pg_query::Node* SelectStmt::add_group_clause() {
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.group_clause)
  return _internal_add_group_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SelectStmt::group_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.group_clause)
  return group_clause_;
}

// .pg_query.Node having_clause = 7 [json_name = "havingClause"];
inline bool SelectStmt::_internal_has_having_clause() const {
  return this != internal_default_instance() && having_clause_ != nullptr;
}
inline bool SelectStmt::has_having_clause() const {
  return _internal_has_having_clause();
}
inline void SelectStmt::clear_having_clause() {
  if (GetArena() == nullptr && having_clause_ != nullptr) {
    delete having_clause_;
  }
  having_clause_ = nullptr;
}
inline const ::pg_query::Node& SelectStmt::_internal_having_clause() const {
  const ::pg_query::Node* p = having_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SelectStmt::having_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.having_clause)
  return _internal_having_clause();
}
inline void SelectStmt::unsafe_arena_set_allocated_having_clause(
    ::pg_query::Node* having_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(having_clause_);
  }
  having_clause_ = having_clause;
  if (having_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.having_clause)
}
inline ::pg_query::Node* SelectStmt::release_having_clause() {
  
  ::pg_query::Node* temp = having_clause_;
  having_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SelectStmt::unsafe_arena_release_having_clause() {
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.having_clause)
  
  ::pg_query::Node* temp = having_clause_;
  having_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SelectStmt::_internal_mutable_having_clause() {
  
  if (having_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    having_clause_ = p;
  }
  return having_clause_;
}
inline ::pg_query::Node* SelectStmt::mutable_having_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.having_clause)
  return _internal_mutable_having_clause();
}
inline void SelectStmt::set_allocated_having_clause(::pg_query::Node* having_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete having_clause_;
  }
  if (having_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(having_clause);
    if (message_arena != submessage_arena) {
      having_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, having_clause, submessage_arena);
    }
    
  } else {
    
  }
  having_clause_ = having_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.having_clause)
}

// repeated .pg_query.Node window_clause = 8 [json_name = "windowClause"];
inline int SelectStmt::_internal_window_clause_size() const {
  return window_clause_.size();
}
inline int SelectStmt::window_clause_size() const {
  return _internal_window_clause_size();
}
inline void SelectStmt::clear_window_clause() {
  window_clause_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_window_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.window_clause)
  return window_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SelectStmt::mutable_window_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.window_clause)
  return &window_clause_;
}
inline const ::pg_query::Node& SelectStmt::_internal_window_clause(int index) const {
  return window_clause_.Get(index);
}
inline const ::pg_query::Node& SelectStmt::window_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.window_clause)
  return _internal_window_clause(index);
}
inline ::pg_query::Node* SelectStmt::_internal_add_window_clause() {
  return window_clause_.Add();
}
inline ::pg_query::Node* SelectStmt::add_window_clause() {
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.window_clause)
  return _internal_add_window_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SelectStmt::window_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.window_clause)
  return window_clause_;
}

// repeated .pg_query.Node values_lists = 9 [json_name = "valuesLists"];
inline int SelectStmt::_internal_values_lists_size() const {
  return values_lists_.size();
}
inline int SelectStmt::values_lists_size() const {
  return _internal_values_lists_size();
}
inline void SelectStmt::clear_values_lists() {
  values_lists_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_values_lists(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.values_lists)
  return values_lists_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SelectStmt::mutable_values_lists() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.values_lists)
  return &values_lists_;
}
inline const ::pg_query::Node& SelectStmt::_internal_values_lists(int index) const {
  return values_lists_.Get(index);
}
inline const ::pg_query::Node& SelectStmt::values_lists(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.values_lists)
  return _internal_values_lists(index);
}
inline ::pg_query::Node* SelectStmt::_internal_add_values_lists() {
  return values_lists_.Add();
}
inline ::pg_query::Node* SelectStmt::add_values_lists() {
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.values_lists)
  return _internal_add_values_lists();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SelectStmt::values_lists() const {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.values_lists)
  return values_lists_;
}

// repeated .pg_query.Node sort_clause = 10 [json_name = "sortClause"];
inline int SelectStmt::_internal_sort_clause_size() const {
  return sort_clause_.size();
}
inline int SelectStmt::sort_clause_size() const {
  return _internal_sort_clause_size();
}
inline void SelectStmt::clear_sort_clause() {
  sort_clause_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_sort_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.sort_clause)
  return sort_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SelectStmt::mutable_sort_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.sort_clause)
  return &sort_clause_;
}
inline const ::pg_query::Node& SelectStmt::_internal_sort_clause(int index) const {
  return sort_clause_.Get(index);
}
inline const ::pg_query::Node& SelectStmt::sort_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.sort_clause)
  return _internal_sort_clause(index);
}
inline ::pg_query::Node* SelectStmt::_internal_add_sort_clause() {
  return sort_clause_.Add();
}
inline ::pg_query::Node* SelectStmt::add_sort_clause() {
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.sort_clause)
  return _internal_add_sort_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SelectStmt::sort_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.sort_clause)
  return sort_clause_;
}

// .pg_query.Node limit_offset = 11 [json_name = "limitOffset"];
inline bool SelectStmt::_internal_has_limit_offset() const {
  return this != internal_default_instance() && limit_offset_ != nullptr;
}
inline bool SelectStmt::has_limit_offset() const {
  return _internal_has_limit_offset();
}
inline void SelectStmt::clear_limit_offset() {
  if (GetArena() == nullptr && limit_offset_ != nullptr) {
    delete limit_offset_;
  }
  limit_offset_ = nullptr;
}
inline const ::pg_query::Node& SelectStmt::_internal_limit_offset() const {
  const ::pg_query::Node* p = limit_offset_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SelectStmt::limit_offset() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.limit_offset)
  return _internal_limit_offset();
}
inline void SelectStmt::unsafe_arena_set_allocated_limit_offset(
    ::pg_query::Node* limit_offset) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(limit_offset_);
  }
  limit_offset_ = limit_offset;
  if (limit_offset) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.limit_offset)
}
inline ::pg_query::Node* SelectStmt::release_limit_offset() {
  
  ::pg_query::Node* temp = limit_offset_;
  limit_offset_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SelectStmt::unsafe_arena_release_limit_offset() {
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.limit_offset)
  
  ::pg_query::Node* temp = limit_offset_;
  limit_offset_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SelectStmt::_internal_mutable_limit_offset() {
  
  if (limit_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    limit_offset_ = p;
  }
  return limit_offset_;
}
inline ::pg_query::Node* SelectStmt::mutable_limit_offset() {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.limit_offset)
  return _internal_mutable_limit_offset();
}
inline void SelectStmt::set_allocated_limit_offset(::pg_query::Node* limit_offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete limit_offset_;
  }
  if (limit_offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(limit_offset);
    if (message_arena != submessage_arena) {
      limit_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, limit_offset, submessage_arena);
    }
    
  } else {
    
  }
  limit_offset_ = limit_offset;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.limit_offset)
}

// .pg_query.Node limit_count = 12 [json_name = "limitCount"];
inline bool SelectStmt::_internal_has_limit_count() const {
  return this != internal_default_instance() && limit_count_ != nullptr;
}
inline bool SelectStmt::has_limit_count() const {
  return _internal_has_limit_count();
}
inline void SelectStmt::clear_limit_count() {
  if (GetArena() == nullptr && limit_count_ != nullptr) {
    delete limit_count_;
  }
  limit_count_ = nullptr;
}
inline const ::pg_query::Node& SelectStmt::_internal_limit_count() const {
  const ::pg_query::Node* p = limit_count_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SelectStmt::limit_count() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.limit_count)
  return _internal_limit_count();
}
inline void SelectStmt::unsafe_arena_set_allocated_limit_count(
    ::pg_query::Node* limit_count) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(limit_count_);
  }
  limit_count_ = limit_count;
  if (limit_count) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.limit_count)
}
inline ::pg_query::Node* SelectStmt::release_limit_count() {
  
  ::pg_query::Node* temp = limit_count_;
  limit_count_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SelectStmt::unsafe_arena_release_limit_count() {
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.limit_count)
  
  ::pg_query::Node* temp = limit_count_;
  limit_count_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SelectStmt::_internal_mutable_limit_count() {
  
  if (limit_count_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    limit_count_ = p;
  }
  return limit_count_;
}
inline ::pg_query::Node* SelectStmt::mutable_limit_count() {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.limit_count)
  return _internal_mutable_limit_count();
}
inline void SelectStmt::set_allocated_limit_count(::pg_query::Node* limit_count) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete limit_count_;
  }
  if (limit_count) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(limit_count);
    if (message_arena != submessage_arena) {
      limit_count = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, limit_count, submessage_arena);
    }
    
  } else {
    
  }
  limit_count_ = limit_count;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.limit_count)
}

// .pg_query.LimitOption limit_option = 13 [json_name = "limitOption"];
inline void SelectStmt::clear_limit_option() {
  limit_option_ = 0;
}
inline ::pg_query::LimitOption SelectStmt::_internal_limit_option() const {
  return static_cast< ::pg_query::LimitOption >(limit_option_);
}
inline ::pg_query::LimitOption SelectStmt::limit_option() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.limit_option)
  return _internal_limit_option();
}
inline void SelectStmt::_internal_set_limit_option(::pg_query::LimitOption value) {
  
  limit_option_ = value;
}
inline void SelectStmt::set_limit_option(::pg_query::LimitOption value) {
  _internal_set_limit_option(value);
  // @@protoc_insertion_point(field_set:pg_query.SelectStmt.limit_option)
}

// repeated .pg_query.Node locking_clause = 14 [json_name = "lockingClause"];
inline int SelectStmt::_internal_locking_clause_size() const {
  return locking_clause_.size();
}
inline int SelectStmt::locking_clause_size() const {
  return _internal_locking_clause_size();
}
inline void SelectStmt::clear_locking_clause() {
  locking_clause_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_locking_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.locking_clause)
  return locking_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SelectStmt::mutable_locking_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.locking_clause)
  return &locking_clause_;
}
inline const ::pg_query::Node& SelectStmt::_internal_locking_clause(int index) const {
  return locking_clause_.Get(index);
}
inline const ::pg_query::Node& SelectStmt::locking_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.locking_clause)
  return _internal_locking_clause(index);
}
inline ::pg_query::Node* SelectStmt::_internal_add_locking_clause() {
  return locking_clause_.Add();
}
inline ::pg_query::Node* SelectStmt::add_locking_clause() {
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.locking_clause)
  return _internal_add_locking_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SelectStmt::locking_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.locking_clause)
  return locking_clause_;
}

// .pg_query.WithClause with_clause = 15 [json_name = "withClause"];
inline bool SelectStmt::_internal_has_with_clause() const {
  return this != internal_default_instance() && with_clause_ != nullptr;
}
inline bool SelectStmt::has_with_clause() const {
  return _internal_has_with_clause();
}
inline void SelectStmt::clear_with_clause() {
  if (GetArena() == nullptr && with_clause_ != nullptr) {
    delete with_clause_;
  }
  with_clause_ = nullptr;
}
inline const ::pg_query::WithClause& SelectStmt::_internal_with_clause() const {
  const ::pg_query::WithClause* p = with_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::WithClause&>(
      ::pg_query::_WithClause_default_instance_);
}
inline const ::pg_query::WithClause& SelectStmt::with_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.with_clause)
  return _internal_with_clause();
}
inline void SelectStmt::unsafe_arena_set_allocated_with_clause(
    ::pg_query::WithClause* with_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(with_clause_);
  }
  with_clause_ = with_clause;
  if (with_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.with_clause)
}
inline ::pg_query::WithClause* SelectStmt::release_with_clause() {
  
  ::pg_query::WithClause* temp = with_clause_;
  with_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::WithClause* SelectStmt::unsafe_arena_release_with_clause() {
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.with_clause)
  
  ::pg_query::WithClause* temp = with_clause_;
  with_clause_ = nullptr;
  return temp;
}
inline ::pg_query::WithClause* SelectStmt::_internal_mutable_with_clause() {
  
  if (with_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArena());
    with_clause_ = p;
  }
  return with_clause_;
}
inline ::pg_query::WithClause* SelectStmt::mutable_with_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.with_clause)
  return _internal_mutable_with_clause();
}
inline void SelectStmt::set_allocated_with_clause(::pg_query::WithClause* with_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete with_clause_;
  }
  if (with_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(with_clause);
    if (message_arena != submessage_arena) {
      with_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, with_clause, submessage_arena);
    }
    
  } else {
    
  }
  with_clause_ = with_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.with_clause)
}

// .pg_query.SetOperation op = 16 [json_name = "op"];
inline void SelectStmt::clear_op() {
  op_ = 0;
}
inline ::pg_query::SetOperation SelectStmt::_internal_op() const {
  return static_cast< ::pg_query::SetOperation >(op_);
}
inline ::pg_query::SetOperation SelectStmt::op() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.op)
  return _internal_op();
}
inline void SelectStmt::_internal_set_op(::pg_query::SetOperation value) {
  
  op_ = value;
}
inline void SelectStmt::set_op(::pg_query::SetOperation value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:pg_query.SelectStmt.op)
}

// bool all = 17 [json_name = "all"];
inline void SelectStmt::clear_all() {
  all_ = false;
}
inline bool SelectStmt::_internal_all() const {
  return all_;
}
inline bool SelectStmt::all() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.all)
  return _internal_all();
}
inline void SelectStmt::_internal_set_all(bool value) {
  
  all_ = value;
}
inline void SelectStmt::set_all(bool value) {
  _internal_set_all(value);
  // @@protoc_insertion_point(field_set:pg_query.SelectStmt.all)
}

// .pg_query.SelectStmt larg = 18 [json_name = "larg"];
inline bool SelectStmt::_internal_has_larg() const {
  return this != internal_default_instance() && larg_ != nullptr;
}
inline bool SelectStmt::has_larg() const {
  return _internal_has_larg();
}
inline void SelectStmt::clear_larg() {
  if (GetArena() == nullptr && larg_ != nullptr) {
    delete larg_;
  }
  larg_ = nullptr;
}
inline const ::pg_query::SelectStmt& SelectStmt::_internal_larg() const {
  const ::pg_query::SelectStmt* p = larg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::SelectStmt&>(
      ::pg_query::_SelectStmt_default_instance_);
}
inline const ::pg_query::SelectStmt& SelectStmt::larg() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.larg)
  return _internal_larg();
}
inline void SelectStmt::unsafe_arena_set_allocated_larg(
    ::pg_query::SelectStmt* larg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(larg_);
  }
  larg_ = larg;
  if (larg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.larg)
}
inline ::pg_query::SelectStmt* SelectStmt::release_larg() {
  
  ::pg_query::SelectStmt* temp = larg_;
  larg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::SelectStmt* SelectStmt::unsafe_arena_release_larg() {
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.larg)
  
  ::pg_query::SelectStmt* temp = larg_;
  larg_ = nullptr;
  return temp;
}
inline ::pg_query::SelectStmt* SelectStmt::_internal_mutable_larg() {
  
  if (larg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::SelectStmt>(GetArena());
    larg_ = p;
  }
  return larg_;
}
inline ::pg_query::SelectStmt* SelectStmt::mutable_larg() {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.larg)
  return _internal_mutable_larg();
}
inline void SelectStmt::set_allocated_larg(::pg_query::SelectStmt* larg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete larg_;
  }
  if (larg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(larg);
    if (message_arena != submessage_arena) {
      larg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, larg, submessage_arena);
    }
    
  } else {
    
  }
  larg_ = larg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.larg)
}

// .pg_query.SelectStmt rarg = 19 [json_name = "rarg"];
inline bool SelectStmt::_internal_has_rarg() const {
  return this != internal_default_instance() && rarg_ != nullptr;
}
inline bool SelectStmt::has_rarg() const {
  return _internal_has_rarg();
}
inline void SelectStmt::clear_rarg() {
  if (GetArena() == nullptr && rarg_ != nullptr) {
    delete rarg_;
  }
  rarg_ = nullptr;
}
inline const ::pg_query::SelectStmt& SelectStmt::_internal_rarg() const {
  const ::pg_query::SelectStmt* p = rarg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::SelectStmt&>(
      ::pg_query::_SelectStmt_default_instance_);
}
inline const ::pg_query::SelectStmt& SelectStmt::rarg() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.rarg)
  return _internal_rarg();
}
inline void SelectStmt::unsafe_arena_set_allocated_rarg(
    ::pg_query::SelectStmt* rarg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rarg_);
  }
  rarg_ = rarg;
  if (rarg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.rarg)
}
inline ::pg_query::SelectStmt* SelectStmt::release_rarg() {
  
  ::pg_query::SelectStmt* temp = rarg_;
  rarg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::SelectStmt* SelectStmt::unsafe_arena_release_rarg() {
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.rarg)
  
  ::pg_query::SelectStmt* temp = rarg_;
  rarg_ = nullptr;
  return temp;
}
inline ::pg_query::SelectStmt* SelectStmt::_internal_mutable_rarg() {
  
  if (rarg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::SelectStmt>(GetArena());
    rarg_ = p;
  }
  return rarg_;
}
inline ::pg_query::SelectStmt* SelectStmt::mutable_rarg() {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.rarg)
  return _internal_mutable_rarg();
}
inline void SelectStmt::set_allocated_rarg(::pg_query::SelectStmt* rarg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete rarg_;
  }
  if (rarg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(rarg);
    if (message_arena != submessage_arena) {
      rarg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rarg, submessage_arena);
    }
    
  } else {
    
  }
  rarg_ = rarg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.rarg)
}

// -------------------------------------------------------------------

// AlterTableStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool AlterTableStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool AlterTableStmt::has_relation() const {
  return _internal_has_relation();
}
inline void AlterTableStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& AlterTableStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& AlterTableStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableStmt.relation)
  return _internal_relation();
}
inline void AlterTableStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterTableStmt.relation)
}
inline ::pg_query::RangeVar* AlterTableStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* AlterTableStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.AlterTableStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* AlterTableStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* AlterTableStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableStmt.relation)
  return _internal_mutable_relation();
}
inline void AlterTableStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableStmt.relation)
}

// repeated .pg_query.Node cmds = 2 [json_name = "cmds"];
inline int AlterTableStmt::_internal_cmds_size() const {
  return cmds_.size();
}
inline int AlterTableStmt::cmds_size() const {
  return _internal_cmds_size();
}
inline void AlterTableStmt::clear_cmds() {
  cmds_.Clear();
}
inline ::pg_query::Node* AlterTableStmt::mutable_cmds(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableStmt.cmds)
  return cmds_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterTableStmt::mutable_cmds() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTableStmt.cmds)
  return &cmds_;
}
inline const ::pg_query::Node& AlterTableStmt::_internal_cmds(int index) const {
  return cmds_.Get(index);
}
inline const ::pg_query::Node& AlterTableStmt::cmds(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableStmt.cmds)
  return _internal_cmds(index);
}
inline ::pg_query::Node* AlterTableStmt::_internal_add_cmds() {
  return cmds_.Add();
}
inline ::pg_query::Node* AlterTableStmt::add_cmds() {
  // @@protoc_insertion_point(field_add:pg_query.AlterTableStmt.cmds)
  return _internal_add_cmds();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterTableStmt::cmds() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterTableStmt.cmds)
  return cmds_;
}

// .pg_query.ObjectType relkind = 3 [json_name = "relkind"];
inline void AlterTableStmt::clear_relkind() {
  relkind_ = 0;
}
inline ::pg_query::ObjectType AlterTableStmt::_internal_relkind() const {
  return static_cast< ::pg_query::ObjectType >(relkind_);
}
inline ::pg_query::ObjectType AlterTableStmt::relkind() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableStmt.relkind)
  return _internal_relkind();
}
inline void AlterTableStmt::_internal_set_relkind(::pg_query::ObjectType value) {
  
  relkind_ = value;
}
inline void AlterTableStmt::set_relkind(::pg_query::ObjectType value) {
  _internal_set_relkind(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableStmt.relkind)
}

// bool missing_ok = 4 [json_name = "missing_ok"];
inline void AlterTableStmt::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool AlterTableStmt::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool AlterTableStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableStmt.missing_ok)
  return _internal_missing_ok();
}
inline void AlterTableStmt::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void AlterTableStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableStmt.missing_ok)
}

// -------------------------------------------------------------------

// AlterTableCmd

// .pg_query.AlterTableType subtype = 1 [json_name = "subtype"];
inline void AlterTableCmd::clear_subtype() {
  subtype_ = 0;
}
inline ::pg_query::AlterTableType AlterTableCmd::_internal_subtype() const {
  return static_cast< ::pg_query::AlterTableType >(subtype_);
}
inline ::pg_query::AlterTableType AlterTableCmd::subtype() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.subtype)
  return _internal_subtype();
}
inline void AlterTableCmd::_internal_set_subtype(::pg_query::AlterTableType value) {
  
  subtype_ = value;
}
inline void AlterTableCmd::set_subtype(::pg_query::AlterTableType value) {
  _internal_set_subtype(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.subtype)
}

// string name = 2 [json_name = "name"];
inline void AlterTableCmd::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& AlterTableCmd::name() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.name)
  return _internal_name();
}
inline void AlterTableCmd::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.name)
}
inline std::string* AlterTableCmd::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableCmd.name)
  return _internal_mutable_name();
}
inline const std::string& AlterTableCmd::_internal_name() const {
  return name_.Get();
}
inline void AlterTableCmd::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterTableCmd::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterTableCmd.name)
}
inline void AlterTableCmd::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterTableCmd.name)
}
inline void AlterTableCmd::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterTableCmd.name)
}
inline std::string* AlterTableCmd::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterTableCmd::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.AlterTableCmd.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterTableCmd::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableCmd.name)
}

// int32 num = 3 [json_name = "num"];
inline void AlterTableCmd::clear_num() {
  num_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 AlterTableCmd::_internal_num() const {
  return num_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 AlterTableCmd::num() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.num)
  return _internal_num();
}
inline void AlterTableCmd::_internal_set_num(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  num_ = value;
}
inline void AlterTableCmd::set_num(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_num(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.num)
}

// .pg_query.RoleSpec newowner = 4 [json_name = "newowner"];
inline bool AlterTableCmd::_internal_has_newowner() const {
  return this != internal_default_instance() && newowner_ != nullptr;
}
inline bool AlterTableCmd::has_newowner() const {
  return _internal_has_newowner();
}
inline void AlterTableCmd::clear_newowner() {
  if (GetArena() == nullptr && newowner_ != nullptr) {
    delete newowner_;
  }
  newowner_ = nullptr;
}
inline const ::pg_query::RoleSpec& AlterTableCmd::_internal_newowner() const {
  const ::pg_query::RoleSpec* p = newowner_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(
      ::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& AlterTableCmd::newowner() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.newowner)
  return _internal_newowner();
}
inline void AlterTableCmd::unsafe_arena_set_allocated_newowner(
    ::pg_query::RoleSpec* newowner) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(newowner_);
  }
  newowner_ = newowner;
  if (newowner) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterTableCmd.newowner)
}
inline ::pg_query::RoleSpec* AlterTableCmd::release_newowner() {
  
  ::pg_query::RoleSpec* temp = newowner_;
  newowner_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RoleSpec* AlterTableCmd::unsafe_arena_release_newowner() {
  // @@protoc_insertion_point(field_release:pg_query.AlterTableCmd.newowner)
  
  ::pg_query::RoleSpec* temp = newowner_;
  newowner_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* AlterTableCmd::_internal_mutable_newowner() {
  
  if (newowner_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    newowner_ = p;
  }
  return newowner_;
}
inline ::pg_query::RoleSpec* AlterTableCmd::mutable_newowner() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableCmd.newowner)
  return _internal_mutable_newowner();
}
inline void AlterTableCmd::set_allocated_newowner(::pg_query::RoleSpec* newowner) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete newowner_;
  }
  if (newowner) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(newowner);
    if (message_arena != submessage_arena) {
      newowner = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, newowner, submessage_arena);
    }
    
  } else {
    
  }
  newowner_ = newowner;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableCmd.newowner)
}

// .pg_query.Node def = 5 [json_name = "def"];
inline bool AlterTableCmd::_internal_has_def() const {
  return this != internal_default_instance() && def_ != nullptr;
}
inline bool AlterTableCmd::has_def() const {
  return _internal_has_def();
}
inline void AlterTableCmd::clear_def() {
  if (GetArena() == nullptr && def_ != nullptr) {
    delete def_;
  }
  def_ = nullptr;
}
inline const ::pg_query::Node& AlterTableCmd::_internal_def() const {
  const ::pg_query::Node* p = def_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterTableCmd::def() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.def)
  return _internal_def();
}
inline void AlterTableCmd::unsafe_arena_set_allocated_def(
    ::pg_query::Node* def) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(def_);
  }
  def_ = def;
  if (def) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterTableCmd.def)
}
inline ::pg_query::Node* AlterTableCmd::release_def() {
  
  ::pg_query::Node* temp = def_;
  def_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* AlterTableCmd::unsafe_arena_release_def() {
  // @@protoc_insertion_point(field_release:pg_query.AlterTableCmd.def)
  
  ::pg_query::Node* temp = def_;
  def_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterTableCmd::_internal_mutable_def() {
  
  if (def_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    def_ = p;
  }
  return def_;
}
inline ::pg_query::Node* AlterTableCmd::mutable_def() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableCmd.def)
  return _internal_mutable_def();
}
inline void AlterTableCmd::set_allocated_def(::pg_query::Node* def) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete def_;
  }
  if (def) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(def);
    if (message_arena != submessage_arena) {
      def = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, def, submessage_arena);
    }
    
  } else {
    
  }
  def_ = def;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableCmd.def)
}

// .pg_query.DropBehavior behavior = 6 [json_name = "behavior"];
inline void AlterTableCmd::clear_behavior() {
  behavior_ = 0;
}
inline ::pg_query::DropBehavior AlterTableCmd::_internal_behavior() const {
  return static_cast< ::pg_query::DropBehavior >(behavior_);
}
inline ::pg_query::DropBehavior AlterTableCmd::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.behavior)
  return _internal_behavior();
}
inline void AlterTableCmd::_internal_set_behavior(::pg_query::DropBehavior value) {
  
  behavior_ = value;
}
inline void AlterTableCmd::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.behavior)
}

// bool missing_ok = 7 [json_name = "missing_ok"];
inline void AlterTableCmd::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool AlterTableCmd::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool AlterTableCmd::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.missing_ok)
  return _internal_missing_ok();
}
inline void AlterTableCmd::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void AlterTableCmd::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.missing_ok)
}

// -------------------------------------------------------------------

// AlterDomainStmt

// string subtype = 1 [json_name = "subtype"];
inline void AlterDomainStmt::clear_subtype() {
  subtype_.ClearToEmpty();
}
inline const std::string& AlterDomainStmt::subtype() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.subtype)
  return _internal_subtype();
}
inline void AlterDomainStmt::set_subtype(const std::string& value) {
  _internal_set_subtype(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterDomainStmt.subtype)
}
inline std::string* AlterDomainStmt::mutable_subtype() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDomainStmt.subtype)
  return _internal_mutable_subtype();
}
inline const std::string& AlterDomainStmt::_internal_subtype() const {
  return subtype_.Get();
}
inline void AlterDomainStmt::_internal_set_subtype(const std::string& value) {
  
  subtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterDomainStmt::set_subtype(std::string&& value) {
  
  subtype_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterDomainStmt.subtype)
}
inline void AlterDomainStmt::set_subtype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  subtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterDomainStmt.subtype)
}
inline void AlterDomainStmt::set_subtype(const char* value,
    size_t size) {
  
  subtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterDomainStmt.subtype)
}
inline std::string* AlterDomainStmt::_internal_mutable_subtype() {
  
  return subtype_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterDomainStmt::release_subtype() {
  // @@protoc_insertion_point(field_release:pg_query.AlterDomainStmt.subtype)
  return subtype_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterDomainStmt::set_allocated_subtype(std::string* subtype) {
  if (subtype != nullptr) {
    
  } else {
    
  }
  subtype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), subtype,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDomainStmt.subtype)
}

// repeated .pg_query.Node type_name = 2 [json_name = "typeName"];
inline int AlterDomainStmt::_internal_type_name_size() const {
  return type_name_.size();
}
inline int AlterDomainStmt::type_name_size() const {
  return _internal_type_name_size();
}
inline void AlterDomainStmt::clear_type_name() {
  type_name_.Clear();
}
inline ::pg_query::Node* AlterDomainStmt::mutable_type_name(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDomainStmt.type_name)
  return type_name_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterDomainStmt::mutable_type_name() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterDomainStmt.type_name)
  return &type_name_;
}
inline const ::pg_query::Node& AlterDomainStmt::_internal_type_name(int index) const {
  return type_name_.Get(index);
}
inline const ::pg_query::Node& AlterDomainStmt::type_name(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.type_name)
  return _internal_type_name(index);
}
inline ::pg_query::Node* AlterDomainStmt::_internal_add_type_name() {
  return type_name_.Add();
}
inline ::pg_query::Node* AlterDomainStmt::add_type_name() {
  // @@protoc_insertion_point(field_add:pg_query.AlterDomainStmt.type_name)
  return _internal_add_type_name();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterDomainStmt::type_name() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterDomainStmt.type_name)
  return type_name_;
}

// string name = 3 [json_name = "name"];
inline void AlterDomainStmt::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& AlterDomainStmt::name() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.name)
  return _internal_name();
}
inline void AlterDomainStmt::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterDomainStmt.name)
}
inline std::string* AlterDomainStmt::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDomainStmt.name)
  return _internal_mutable_name();
}
inline const std::string& AlterDomainStmt::_internal_name() const {
  return name_.Get();
}
inline void AlterDomainStmt::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterDomainStmt::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterDomainStmt.name)
}
inline void AlterDomainStmt::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterDomainStmt.name)
}
inline void AlterDomainStmt::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterDomainStmt.name)
}
inline std::string* AlterDomainStmt::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterDomainStmt::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.AlterDomainStmt.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterDomainStmt::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDomainStmt.name)
}

// .pg_query.Node def = 4 [json_name = "def"];
inline bool AlterDomainStmt::_internal_has_def() const {
  return this != internal_default_instance() && def_ != nullptr;
}
inline bool AlterDomainStmt::has_def() const {
  return _internal_has_def();
}
inline void AlterDomainStmt::clear_def() {
  if (GetArena() == nullptr && def_ != nullptr) {
    delete def_;
  }
  def_ = nullptr;
}
inline const ::pg_query::Node& AlterDomainStmt::_internal_def() const {
  const ::pg_query::Node* p = def_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterDomainStmt::def() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.def)
  return _internal_def();
}
inline void AlterDomainStmt::unsafe_arena_set_allocated_def(
    ::pg_query::Node* def) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(def_);
  }
  def_ = def;
  if (def) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterDomainStmt.def)
}
inline ::pg_query::Node* AlterDomainStmt::release_def() {
  
  ::pg_query::Node* temp = def_;
  def_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* AlterDomainStmt::unsafe_arena_release_def() {
  // @@protoc_insertion_point(field_release:pg_query.AlterDomainStmt.def)
  
  ::pg_query::Node* temp = def_;
  def_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterDomainStmt::_internal_mutable_def() {
  
  if (def_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    def_ = p;
  }
  return def_;
}
inline ::pg_query::Node* AlterDomainStmt::mutable_def() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDomainStmt.def)
  return _internal_mutable_def();
}
inline void AlterDomainStmt::set_allocated_def(::pg_query::Node* def) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete def_;
  }
  if (def) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(def);
    if (message_arena != submessage_arena) {
      def = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, def, submessage_arena);
    }
    
  } else {
    
  }
  def_ = def;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDomainStmt.def)
}

// .pg_query.DropBehavior behavior = 5 [json_name = "behavior"];
inline void AlterDomainStmt::clear_behavior() {
  behavior_ = 0;
}
inline ::pg_query::DropBehavior AlterDomainStmt::_internal_behavior() const {
  return static_cast< ::pg_query::DropBehavior >(behavior_);
}
inline ::pg_query::DropBehavior AlterDomainStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.behavior)
  return _internal_behavior();
}
inline void AlterDomainStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  
  behavior_ = value;
}
inline void AlterDomainStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterDomainStmt.behavior)
}

// bool missing_ok = 6 [json_name = "missing_ok"];
inline void AlterDomainStmt::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool AlterDomainStmt::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool AlterDomainStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.missing_ok)
  return _internal_missing_ok();
}
inline void AlterDomainStmt::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void AlterDomainStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterDomainStmt.missing_ok)
}

// -------------------------------------------------------------------

// SetOperationStmt

// .pg_query.SetOperation op = 1 [json_name = "op"];
inline void SetOperationStmt::clear_op() {
  op_ = 0;
}
inline ::pg_query::SetOperation SetOperationStmt::_internal_op() const {
  return static_cast< ::pg_query::SetOperation >(op_);
}
inline ::pg_query::SetOperation SetOperationStmt::op() const {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.op)
  return _internal_op();
}
inline void SetOperationStmt::_internal_set_op(::pg_query::SetOperation value) {
  
  op_ = value;
}
inline void SetOperationStmt::set_op(::pg_query::SetOperation value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:pg_query.SetOperationStmt.op)
}

// bool all = 2 [json_name = "all"];
inline void SetOperationStmt::clear_all() {
  all_ = false;
}
inline bool SetOperationStmt::_internal_all() const {
  return all_;
}
inline bool SetOperationStmt::all() const {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.all)
  return _internal_all();
}
inline void SetOperationStmt::_internal_set_all(bool value) {
  
  all_ = value;
}
inline void SetOperationStmt::set_all(bool value) {
  _internal_set_all(value);
  // @@protoc_insertion_point(field_set:pg_query.SetOperationStmt.all)
}

// .pg_query.Node larg = 3 [json_name = "larg"];
inline bool SetOperationStmt::_internal_has_larg() const {
  return this != internal_default_instance() && larg_ != nullptr;
}
inline bool SetOperationStmt::has_larg() const {
  return _internal_has_larg();
}
inline void SetOperationStmt::clear_larg() {
  if (GetArena() == nullptr && larg_ != nullptr) {
    delete larg_;
  }
  larg_ = nullptr;
}
inline const ::pg_query::Node& SetOperationStmt::_internal_larg() const {
  const ::pg_query::Node* p = larg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SetOperationStmt::larg() const {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.larg)
  return _internal_larg();
}
inline void SetOperationStmt::unsafe_arena_set_allocated_larg(
    ::pg_query::Node* larg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(larg_);
  }
  larg_ = larg;
  if (larg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SetOperationStmt.larg)
}
inline ::pg_query::Node* SetOperationStmt::release_larg() {
  
  ::pg_query::Node* temp = larg_;
  larg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SetOperationStmt::unsafe_arena_release_larg() {
  // @@protoc_insertion_point(field_release:pg_query.SetOperationStmt.larg)
  
  ::pg_query::Node* temp = larg_;
  larg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SetOperationStmt::_internal_mutable_larg() {
  
  if (larg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    larg_ = p;
  }
  return larg_;
}
inline ::pg_query::Node* SetOperationStmt::mutable_larg() {
  // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.larg)
  return _internal_mutable_larg();
}
inline void SetOperationStmt::set_allocated_larg(::pg_query::Node* larg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete larg_;
  }
  if (larg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(larg);
    if (message_arena != submessage_arena) {
      larg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, larg, submessage_arena);
    }
    
  } else {
    
  }
  larg_ = larg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SetOperationStmt.larg)
}

// .pg_query.Node rarg = 4 [json_name = "rarg"];
inline bool SetOperationStmt::_internal_has_rarg() const {
  return this != internal_default_instance() && rarg_ != nullptr;
}
inline bool SetOperationStmt::has_rarg() const {
  return _internal_has_rarg();
}
inline void SetOperationStmt::clear_rarg() {
  if (GetArena() == nullptr && rarg_ != nullptr) {
    delete rarg_;
  }
  rarg_ = nullptr;
}
inline const ::pg_query::Node& SetOperationStmt::_internal_rarg() const {
  const ::pg_query::Node* p = rarg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SetOperationStmt::rarg() const {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.rarg)
  return _internal_rarg();
}
inline void SetOperationStmt::unsafe_arena_set_allocated_rarg(
    ::pg_query::Node* rarg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rarg_);
  }
  rarg_ = rarg;
  if (rarg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SetOperationStmt.rarg)
}
inline ::pg_query::Node* SetOperationStmt::release_rarg() {
  
  ::pg_query::Node* temp = rarg_;
  rarg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SetOperationStmt::unsafe_arena_release_rarg() {
  // @@protoc_insertion_point(field_release:pg_query.SetOperationStmt.rarg)
  
  ::pg_query::Node* temp = rarg_;
  rarg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SetOperationStmt::_internal_mutable_rarg() {
  
  if (rarg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    rarg_ = p;
  }
  return rarg_;
}
inline ::pg_query::Node* SetOperationStmt::mutable_rarg() {
  // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.rarg)
  return _internal_mutable_rarg();
}
inline void SetOperationStmt::set_allocated_rarg(::pg_query::Node* rarg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete rarg_;
  }
  if (rarg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(rarg);
    if (message_arena != submessage_arena) {
      rarg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rarg, submessage_arena);
    }
    
  } else {
    
  }
  rarg_ = rarg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SetOperationStmt.rarg)
}

// repeated .pg_query.Node col_types = 5 [json_name = "colTypes"];
inline int SetOperationStmt::_internal_col_types_size() const {
  return col_types_.size();
}
inline int SetOperationStmt::col_types_size() const {
  return _internal_col_types_size();
}
inline void SetOperationStmt::clear_col_types() {
  col_types_.Clear();
}
inline ::pg_query::Node* SetOperationStmt::mutable_col_types(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.col_types)
  return col_types_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SetOperationStmt::mutable_col_types() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SetOperationStmt.col_types)
  return &col_types_;
}
inline const ::pg_query::Node& SetOperationStmt::_internal_col_types(int index) const {
  return col_types_.Get(index);
}
inline const ::pg_query::Node& SetOperationStmt::col_types(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.col_types)
  return _internal_col_types(index);
}
inline ::pg_query::Node* SetOperationStmt::_internal_add_col_types() {
  return col_types_.Add();
}
inline ::pg_query::Node* SetOperationStmt::add_col_types() {
  // @@protoc_insertion_point(field_add:pg_query.SetOperationStmt.col_types)
  return _internal_add_col_types();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SetOperationStmt::col_types() const {
  // @@protoc_insertion_point(field_list:pg_query.SetOperationStmt.col_types)
  return col_types_;
}

// repeated .pg_query.Node col_typmods = 6 [json_name = "colTypmods"];
inline int SetOperationStmt::_internal_col_typmods_size() const {
  return col_typmods_.size();
}
inline int SetOperationStmt::col_typmods_size() const {
  return _internal_col_typmods_size();
}
inline void SetOperationStmt::clear_col_typmods() {
  col_typmods_.Clear();
}
inline ::pg_query::Node* SetOperationStmt::mutable_col_typmods(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.col_typmods)
  return col_typmods_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SetOperationStmt::mutable_col_typmods() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SetOperationStmt.col_typmods)
  return &col_typmods_;
}
inline const ::pg_query::Node& SetOperationStmt::_internal_col_typmods(int index) const {
  return col_typmods_.Get(index);
}
inline const ::pg_query::Node& SetOperationStmt::col_typmods(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.col_typmods)
  return _internal_col_typmods(index);
}
inline ::pg_query::Node* SetOperationStmt::_internal_add_col_typmods() {
  return col_typmods_.Add();
}
inline ::pg_query::Node* SetOperationStmt::add_col_typmods() {
  // @@protoc_insertion_point(field_add:pg_query.SetOperationStmt.col_typmods)
  return _internal_add_col_typmods();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SetOperationStmt::col_typmods() const {
  // @@protoc_insertion_point(field_list:pg_query.SetOperationStmt.col_typmods)
  return col_typmods_;
}

// repeated .pg_query.Node col_collations = 7 [json_name = "colCollations"];
inline int SetOperationStmt::_internal_col_collations_size() const {
  return col_collations_.size();
}
inline int SetOperationStmt::col_collations_size() const {
  return _internal_col_collations_size();
}
inline void SetOperationStmt::clear_col_collations() {
  col_collations_.Clear();
}
inline ::pg_query::Node* SetOperationStmt::mutable_col_collations(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.col_collations)
  return col_collations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SetOperationStmt::mutable_col_collations() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SetOperationStmt.col_collations)
  return &col_collations_;
}
inline const ::pg_query::Node& SetOperationStmt::_internal_col_collations(int index) const {
  return col_collations_.Get(index);
}
inline const ::pg_query::Node& SetOperationStmt::col_collations(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.col_collations)
  return _internal_col_collations(index);
}
inline ::pg_query::Node* SetOperationStmt::_internal_add_col_collations() {
  return col_collations_.Add();
}
inline ::pg_query::Node* SetOperationStmt::add_col_collations() {
  // @@protoc_insertion_point(field_add:pg_query.SetOperationStmt.col_collations)
  return _internal_add_col_collations();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SetOperationStmt::col_collations() const {
  // @@protoc_insertion_point(field_list:pg_query.SetOperationStmt.col_collations)
  return col_collations_;
}

// repeated .pg_query.Node group_clauses = 8 [json_name = "groupClauses"];
inline int SetOperationStmt::_internal_group_clauses_size() const {
  return group_clauses_.size();
}
inline int SetOperationStmt::group_clauses_size() const {
  return _internal_group_clauses_size();
}
inline void SetOperationStmt::clear_group_clauses() {
  group_clauses_.Clear();
}
inline ::pg_query::Node* SetOperationStmt::mutable_group_clauses(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.group_clauses)
  return group_clauses_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SetOperationStmt::mutable_group_clauses() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SetOperationStmt.group_clauses)
  return &group_clauses_;
}
inline const ::pg_query::Node& SetOperationStmt::_internal_group_clauses(int index) const {
  return group_clauses_.Get(index);
}
inline const ::pg_query::Node& SetOperationStmt::group_clauses(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.group_clauses)
  return _internal_group_clauses(index);
}
inline ::pg_query::Node* SetOperationStmt::_internal_add_group_clauses() {
  return group_clauses_.Add();
}
inline ::pg_query::Node* SetOperationStmt::add_group_clauses() {
  // @@protoc_insertion_point(field_add:pg_query.SetOperationStmt.group_clauses)
  return _internal_add_group_clauses();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SetOperationStmt::group_clauses() const {
  // @@protoc_insertion_point(field_list:pg_query.SetOperationStmt.group_clauses)
  return group_clauses_;
}

// -------------------------------------------------------------------

// GrantStmt

// bool is_grant = 1 [json_name = "is_grant"];
inline void GrantStmt::clear_is_grant() {
  is_grant_ = false;
}
inline bool GrantStmt::_internal_is_grant() const {
  return is_grant_;
}
inline bool GrantStmt::is_grant() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.is_grant)
  return _internal_is_grant();
}
inline void GrantStmt::_internal_set_is_grant(bool value) {
  
  is_grant_ = value;
}
inline void GrantStmt::set_is_grant(bool value) {
  _internal_set_is_grant(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantStmt.is_grant)
}

// .pg_query.GrantTargetType targtype = 2 [json_name = "targtype"];
inline void GrantStmt::clear_targtype() {
  targtype_ = 0;
}
inline ::pg_query::GrantTargetType GrantStmt::_internal_targtype() const {
  return static_cast< ::pg_query::GrantTargetType >(targtype_);
}
inline ::pg_query::GrantTargetType GrantStmt::targtype() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.targtype)
  return _internal_targtype();
}
inline void GrantStmt::_internal_set_targtype(::pg_query::GrantTargetType value) {
  
  targtype_ = value;
}
inline void GrantStmt::set_targtype(::pg_query::GrantTargetType value) {
  _internal_set_targtype(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantStmt.targtype)
}

// .pg_query.ObjectType objtype = 3 [json_name = "objtype"];
inline void GrantStmt::clear_objtype() {
  objtype_ = 0;
}
inline ::pg_query::ObjectType GrantStmt::_internal_objtype() const {
  return static_cast< ::pg_query::ObjectType >(objtype_);
}
inline ::pg_query::ObjectType GrantStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.objtype)
  return _internal_objtype();
}
inline void GrantStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  
  objtype_ = value;
}
inline void GrantStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantStmt.objtype)
}

// repeated .pg_query.Node objects = 4 [json_name = "objects"];
inline int GrantStmt::_internal_objects_size() const {
  return objects_.size();
}
inline int GrantStmt::objects_size() const {
  return _internal_objects_size();
}
inline void GrantStmt::clear_objects() {
  objects_.Clear();
}
inline ::pg_query::Node* GrantStmt::mutable_objects(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.GrantStmt.objects)
  return objects_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
GrantStmt::mutable_objects() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GrantStmt.objects)
  return &objects_;
}
inline const ::pg_query::Node& GrantStmt::_internal_objects(int index) const {
  return objects_.Get(index);
}
inline const ::pg_query::Node& GrantStmt::objects(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.objects)
  return _internal_objects(index);
}
inline ::pg_query::Node* GrantStmt::_internal_add_objects() {
  return objects_.Add();
}
inline ::pg_query::Node* GrantStmt::add_objects() {
  // @@protoc_insertion_point(field_add:pg_query.GrantStmt.objects)
  return _internal_add_objects();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
GrantStmt::objects() const {
  // @@protoc_insertion_point(field_list:pg_query.GrantStmt.objects)
  return objects_;
}

// repeated .pg_query.Node privileges = 5 [json_name = "privileges"];
inline int GrantStmt::_internal_privileges_size() const {
  return privileges_.size();
}
inline int GrantStmt::privileges_size() const {
  return _internal_privileges_size();
}
inline void GrantStmt::clear_privileges() {
  privileges_.Clear();
}
inline ::pg_query::Node* GrantStmt::mutable_privileges(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.GrantStmt.privileges)
  return privileges_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
GrantStmt::mutable_privileges() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GrantStmt.privileges)
  return &privileges_;
}
inline const ::pg_query::Node& GrantStmt::_internal_privileges(int index) const {
  return privileges_.Get(index);
}
inline const ::pg_query::Node& GrantStmt::privileges(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.privileges)
  return _internal_privileges(index);
}
inline ::pg_query::Node* GrantStmt::_internal_add_privileges() {
  return privileges_.Add();
}
inline ::pg_query::Node* GrantStmt::add_privileges() {
  // @@protoc_insertion_point(field_add:pg_query.GrantStmt.privileges)
  return _internal_add_privileges();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
GrantStmt::privileges() const {
  // @@protoc_insertion_point(field_list:pg_query.GrantStmt.privileges)
  return privileges_;
}

// repeated .pg_query.Node grantees = 6 [json_name = "grantees"];
inline int GrantStmt::_internal_grantees_size() const {
  return grantees_.size();
}
inline int GrantStmt::grantees_size() const {
  return _internal_grantees_size();
}
inline void GrantStmt::clear_grantees() {
  grantees_.Clear();
}
inline ::pg_query::Node* GrantStmt::mutable_grantees(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.GrantStmt.grantees)
  return grantees_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
GrantStmt::mutable_grantees() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GrantStmt.grantees)
  return &grantees_;
}
inline const ::pg_query::Node& GrantStmt::_internal_grantees(int index) const {
  return grantees_.Get(index);
}
inline const ::pg_query::Node& GrantStmt::grantees(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.grantees)
  return _internal_grantees(index);
}
inline ::pg_query::Node* GrantStmt::_internal_add_grantees() {
  return grantees_.Add();
}
inline ::pg_query::Node* GrantStmt::add_grantees() {
  // @@protoc_insertion_point(field_add:pg_query.GrantStmt.grantees)
  return _internal_add_grantees();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
GrantStmt::grantees() const {
  // @@protoc_insertion_point(field_list:pg_query.GrantStmt.grantees)
  return grantees_;
}

// bool grant_option = 7 [json_name = "grant_option"];
inline void GrantStmt::clear_grant_option() {
  grant_option_ = false;
}
inline bool GrantStmt::_internal_grant_option() const {
  return grant_option_;
}
inline bool GrantStmt::grant_option() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.grant_option)
  return _internal_grant_option();
}
inline void GrantStmt::_internal_set_grant_option(bool value) {
  
  grant_option_ = value;
}
inline void GrantStmt::set_grant_option(bool value) {
  _internal_set_grant_option(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantStmt.grant_option)
}

// .pg_query.DropBehavior behavior = 8 [json_name = "behavior"];
inline void GrantStmt::clear_behavior() {
  behavior_ = 0;
}
inline ::pg_query::DropBehavior GrantStmt::_internal_behavior() const {
  return static_cast< ::pg_query::DropBehavior >(behavior_);
}
inline ::pg_query::DropBehavior GrantStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.behavior)
  return _internal_behavior();
}
inline void GrantStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  
  behavior_ = value;
}
inline void GrantStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantStmt.behavior)
}

// -------------------------------------------------------------------

// GrantRoleStmt

// repeated .pg_query.Node granted_roles = 1 [json_name = "granted_roles"];
inline int GrantRoleStmt::_internal_granted_roles_size() const {
  return granted_roles_.size();
}
inline int GrantRoleStmt::granted_roles_size() const {
  return _internal_granted_roles_size();
}
inline void GrantRoleStmt::clear_granted_roles() {
  granted_roles_.Clear();
}
inline ::pg_query::Node* GrantRoleStmt::mutable_granted_roles(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.GrantRoleStmt.granted_roles)
  return granted_roles_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
GrantRoleStmt::mutable_granted_roles() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GrantRoleStmt.granted_roles)
  return &granted_roles_;
}
inline const ::pg_query::Node& GrantRoleStmt::_internal_granted_roles(int index) const {
  return granted_roles_.Get(index);
}
inline const ::pg_query::Node& GrantRoleStmt::granted_roles(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.granted_roles)
  return _internal_granted_roles(index);
}
inline ::pg_query::Node* GrantRoleStmt::_internal_add_granted_roles() {
  return granted_roles_.Add();
}
inline ::pg_query::Node* GrantRoleStmt::add_granted_roles() {
  // @@protoc_insertion_point(field_add:pg_query.GrantRoleStmt.granted_roles)
  return _internal_add_granted_roles();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
GrantRoleStmt::granted_roles() const {
  // @@protoc_insertion_point(field_list:pg_query.GrantRoleStmt.granted_roles)
  return granted_roles_;
}

// repeated .pg_query.Node grantee_roles = 2 [json_name = "grantee_roles"];
inline int GrantRoleStmt::_internal_grantee_roles_size() const {
  return grantee_roles_.size();
}
inline int GrantRoleStmt::grantee_roles_size() const {
  return _internal_grantee_roles_size();
}
inline void GrantRoleStmt::clear_grantee_roles() {
  grantee_roles_.Clear();
}
inline ::pg_query::Node* GrantRoleStmt::mutable_grantee_roles(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.GrantRoleStmt.grantee_roles)
  return grantee_roles_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
GrantRoleStmt::mutable_grantee_roles() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GrantRoleStmt.grantee_roles)
  return &grantee_roles_;
}
inline const ::pg_query::Node& GrantRoleStmt::_internal_grantee_roles(int index) const {
  return grantee_roles_.Get(index);
}
inline const ::pg_query::Node& GrantRoleStmt::grantee_roles(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.grantee_roles)
  return _internal_grantee_roles(index);
}
inline ::pg_query::Node* GrantRoleStmt::_internal_add_grantee_roles() {
  return grantee_roles_.Add();
}
inline ::pg_query::Node* GrantRoleStmt::add_grantee_roles() {
  // @@protoc_insertion_point(field_add:pg_query.GrantRoleStmt.grantee_roles)
  return _internal_add_grantee_roles();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
GrantRoleStmt::grantee_roles() const {
  // @@protoc_insertion_point(field_list:pg_query.GrantRoleStmt.grantee_roles)
  return grantee_roles_;
}

// bool is_grant = 3 [json_name = "is_grant"];
inline void GrantRoleStmt::clear_is_grant() {
  is_grant_ = false;
}
inline bool GrantRoleStmt::_internal_is_grant() const {
  return is_grant_;
}
inline bool GrantRoleStmt::is_grant() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.is_grant)
  return _internal_is_grant();
}
inline void GrantRoleStmt::_internal_set_is_grant(bool value) {
  
  is_grant_ = value;
}
inline void GrantRoleStmt::set_is_grant(bool value) {
  _internal_set_is_grant(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantRoleStmt.is_grant)
}

// bool admin_opt = 4 [json_name = "admin_opt"];
inline void GrantRoleStmt::clear_admin_opt() {
  admin_opt_ = false;
}
inline bool GrantRoleStmt::_internal_admin_opt() const {
  return admin_opt_;
}
inline bool GrantRoleStmt::admin_opt() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.admin_opt)
  return _internal_admin_opt();
}
inline void GrantRoleStmt::_internal_set_admin_opt(bool value) {
  
  admin_opt_ = value;
}
inline void GrantRoleStmt::set_admin_opt(bool value) {
  _internal_set_admin_opt(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantRoleStmt.admin_opt)
}

// .pg_query.RoleSpec grantor = 5 [json_name = "grantor"];
inline bool GrantRoleStmt::_internal_has_grantor() const {
  return this != internal_default_instance() && grantor_ != nullptr;
}
inline bool GrantRoleStmt::has_grantor() const {
  return _internal_has_grantor();
}
inline void GrantRoleStmt::clear_grantor() {
  if (GetArena() == nullptr && grantor_ != nullptr) {
    delete grantor_;
  }
  grantor_ = nullptr;
}
inline const ::pg_query::RoleSpec& GrantRoleStmt::_internal_grantor() const {
  const ::pg_query::RoleSpec* p = grantor_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(
      ::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& GrantRoleStmt::grantor() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.grantor)
  return _internal_grantor();
}
inline void GrantRoleStmt::unsafe_arena_set_allocated_grantor(
    ::pg_query::RoleSpec* grantor) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(grantor_);
  }
  grantor_ = grantor;
  if (grantor) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.GrantRoleStmt.grantor)
}
inline ::pg_query::RoleSpec* GrantRoleStmt::release_grantor() {
  
  ::pg_query::RoleSpec* temp = grantor_;
  grantor_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RoleSpec* GrantRoleStmt::unsafe_arena_release_grantor() {
  // @@protoc_insertion_point(field_release:pg_query.GrantRoleStmt.grantor)
  
  ::pg_query::RoleSpec* temp = grantor_;
  grantor_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* GrantRoleStmt::_internal_mutable_grantor() {
  
  if (grantor_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    grantor_ = p;
  }
  return grantor_;
}
inline ::pg_query::RoleSpec* GrantRoleStmt::mutable_grantor() {
  // @@protoc_insertion_point(field_mutable:pg_query.GrantRoleStmt.grantor)
  return _internal_mutable_grantor();
}
inline void GrantRoleStmt::set_allocated_grantor(::pg_query::RoleSpec* grantor) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete grantor_;
  }
  if (grantor) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(grantor);
    if (message_arena != submessage_arena) {
      grantor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, grantor, submessage_arena);
    }
    
  } else {
    
  }
  grantor_ = grantor;
  // @@protoc_insertion_point(field_set_allocated:pg_query.GrantRoleStmt.grantor)
}

// .pg_query.DropBehavior behavior = 6 [json_name = "behavior"];
inline void GrantRoleStmt::clear_behavior() {
  behavior_ = 0;
}
inline ::pg_query::DropBehavior GrantRoleStmt::_internal_behavior() const {
  return static_cast< ::pg_query::DropBehavior >(behavior_);
}
inline ::pg_query::DropBehavior GrantRoleStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.behavior)
  return _internal_behavior();
}
inline void GrantRoleStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  
  behavior_ = value;
}
inline void GrantRoleStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantRoleStmt.behavior)
}

// -------------------------------------------------------------------

// AlterDefaultPrivilegesStmt

// repeated .pg_query.Node options = 1 [json_name = "options"];
inline int AlterDefaultPrivilegesStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterDefaultPrivilegesStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterDefaultPrivilegesStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterDefaultPrivilegesStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDefaultPrivilegesStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterDefaultPrivilegesStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterDefaultPrivilegesStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterDefaultPrivilegesStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterDefaultPrivilegesStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDefaultPrivilegesStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterDefaultPrivilegesStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterDefaultPrivilegesStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterDefaultPrivilegesStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterDefaultPrivilegesStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterDefaultPrivilegesStmt.options)
  return options_;
}

// .pg_query.GrantStmt action = 2 [json_name = "action"];
inline bool AlterDefaultPrivilegesStmt::_internal_has_action() const {
  return this != internal_default_instance() && action_ != nullptr;
}
inline bool AlterDefaultPrivilegesStmt::has_action() const {
  return _internal_has_action();
}
inline void AlterDefaultPrivilegesStmt::clear_action() {
  if (GetArena() == nullptr && action_ != nullptr) {
    delete action_;
  }
  action_ = nullptr;
}
inline const ::pg_query::GrantStmt& AlterDefaultPrivilegesStmt::_internal_action() const {
  const ::pg_query::GrantStmt* p = action_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::GrantStmt&>(
      ::pg_query::_GrantStmt_default_instance_);
}
inline const ::pg_query::GrantStmt& AlterDefaultPrivilegesStmt::action() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDefaultPrivilegesStmt.action)
  return _internal_action();
}
inline void AlterDefaultPrivilegesStmt::unsafe_arena_set_allocated_action(
    ::pg_query::GrantStmt* action) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(action_);
  }
  action_ = action;
  if (action) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterDefaultPrivilegesStmt.action)
}
inline ::pg_query::GrantStmt* AlterDefaultPrivilegesStmt::release_action() {
  
  ::pg_query::GrantStmt* temp = action_;
  action_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::GrantStmt* AlterDefaultPrivilegesStmt::unsafe_arena_release_action() {
  // @@protoc_insertion_point(field_release:pg_query.AlterDefaultPrivilegesStmt.action)
  
  ::pg_query::GrantStmt* temp = action_;
  action_ = nullptr;
  return temp;
}
inline ::pg_query::GrantStmt* AlterDefaultPrivilegesStmt::_internal_mutable_action() {
  
  if (action_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::GrantStmt>(GetArena());
    action_ = p;
  }
  return action_;
}
inline ::pg_query::GrantStmt* AlterDefaultPrivilegesStmt::mutable_action() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDefaultPrivilegesStmt.action)
  return _internal_mutable_action();
}
inline void AlterDefaultPrivilegesStmt::set_allocated_action(::pg_query::GrantStmt* action) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete action_;
  }
  if (action) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(action);
    if (message_arena != submessage_arena) {
      action = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, action, submessage_arena);
    }
    
  } else {
    
  }
  action_ = action;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDefaultPrivilegesStmt.action)
}

// -------------------------------------------------------------------

// ClosePortalStmt

// string portalname = 1 [json_name = "portalname"];
inline void ClosePortalStmt::clear_portalname() {
  portalname_.ClearToEmpty();
}
inline const std::string& ClosePortalStmt::portalname() const {
  // @@protoc_insertion_point(field_get:pg_query.ClosePortalStmt.portalname)
  return _internal_portalname();
}
inline void ClosePortalStmt::set_portalname(const std::string& value) {
  _internal_set_portalname(value);
  // @@protoc_insertion_point(field_set:pg_query.ClosePortalStmt.portalname)
}
inline std::string* ClosePortalStmt::mutable_portalname() {
  // @@protoc_insertion_point(field_mutable:pg_query.ClosePortalStmt.portalname)
  return _internal_mutable_portalname();
}
inline const std::string& ClosePortalStmt::_internal_portalname() const {
  return portalname_.Get();
}
inline void ClosePortalStmt::_internal_set_portalname(const std::string& value) {
  
  portalname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ClosePortalStmt::set_portalname(std::string&& value) {
  
  portalname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ClosePortalStmt.portalname)
}
inline void ClosePortalStmt::set_portalname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  portalname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ClosePortalStmt.portalname)
}
inline void ClosePortalStmt::set_portalname(const char* value,
    size_t size) {
  
  portalname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ClosePortalStmt.portalname)
}
inline std::string* ClosePortalStmt::_internal_mutable_portalname() {
  
  return portalname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ClosePortalStmt::release_portalname() {
  // @@protoc_insertion_point(field_release:pg_query.ClosePortalStmt.portalname)
  return portalname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ClosePortalStmt::set_allocated_portalname(std::string* portalname) {
  if (portalname != nullptr) {
    
  } else {
    
  }
  portalname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), portalname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ClosePortalStmt.portalname)
}

// -------------------------------------------------------------------

// ClusterStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool ClusterStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool ClusterStmt::has_relation() const {
  return _internal_has_relation();
}
inline void ClusterStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& ClusterStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& ClusterStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.ClusterStmt.relation)
  return _internal_relation();
}
inline void ClusterStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ClusterStmt.relation)
}
inline ::pg_query::RangeVar* ClusterStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* ClusterStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.ClusterStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* ClusterStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* ClusterStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.ClusterStmt.relation)
  return _internal_mutable_relation();
}
inline void ClusterStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ClusterStmt.relation)
}

// string indexname = 2 [json_name = "indexname"];
inline void ClusterStmt::clear_indexname() {
  indexname_.ClearToEmpty();
}
inline const std::string& ClusterStmt::indexname() const {
  // @@protoc_insertion_point(field_get:pg_query.ClusterStmt.indexname)
  return _internal_indexname();
}
inline void ClusterStmt::set_indexname(const std::string& value) {
  _internal_set_indexname(value);
  // @@protoc_insertion_point(field_set:pg_query.ClusterStmt.indexname)
}
inline std::string* ClusterStmt::mutable_indexname() {
  // @@protoc_insertion_point(field_mutable:pg_query.ClusterStmt.indexname)
  return _internal_mutable_indexname();
}
inline const std::string& ClusterStmt::_internal_indexname() const {
  return indexname_.Get();
}
inline void ClusterStmt::_internal_set_indexname(const std::string& value) {
  
  indexname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ClusterStmt::set_indexname(std::string&& value) {
  
  indexname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ClusterStmt.indexname)
}
inline void ClusterStmt::set_indexname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  indexname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ClusterStmt.indexname)
}
inline void ClusterStmt::set_indexname(const char* value,
    size_t size) {
  
  indexname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ClusterStmt.indexname)
}
inline std::string* ClusterStmt::_internal_mutable_indexname() {
  
  return indexname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ClusterStmt::release_indexname() {
  // @@protoc_insertion_point(field_release:pg_query.ClusterStmt.indexname)
  return indexname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ClusterStmt::set_allocated_indexname(std::string* indexname) {
  if (indexname != nullptr) {
    
  } else {
    
  }
  indexname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), indexname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ClusterStmt.indexname)
}

// int32 options = 3 [json_name = "options"];
inline void ClusterStmt::clear_options() {
  options_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ClusterStmt::_internal_options() const {
  return options_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ClusterStmt::options() const {
  // @@protoc_insertion_point(field_get:pg_query.ClusterStmt.options)
  return _internal_options();
}
inline void ClusterStmt::_internal_set_options(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  options_ = value;
}
inline void ClusterStmt::set_options(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_options(value);
  // @@protoc_insertion_point(field_set:pg_query.ClusterStmt.options)
}

// -------------------------------------------------------------------

// CopyStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool CopyStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool CopyStmt::has_relation() const {
  return _internal_has_relation();
}
inline void CopyStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& CopyStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CopyStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.relation)
  return _internal_relation();
}
inline void CopyStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CopyStmt.relation)
}
inline ::pg_query::RangeVar* CopyStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* CopyStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.CopyStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CopyStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* CopyStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.relation)
  return _internal_mutable_relation();
}
inline void CopyStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CopyStmt.relation)
}

// .pg_query.Node query = 2 [json_name = "query"];
inline bool CopyStmt::_internal_has_query() const {
  return this != internal_default_instance() && query_ != nullptr;
}
inline bool CopyStmt::has_query() const {
  return _internal_has_query();
}
inline void CopyStmt::clear_query() {
  if (GetArena() == nullptr && query_ != nullptr) {
    delete query_;
  }
  query_ = nullptr;
}
inline const ::pg_query::Node& CopyStmt::_internal_query() const {
  const ::pg_query::Node* p = query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CopyStmt::query() const {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.query)
  return _internal_query();
}
inline void CopyStmt::unsafe_arena_set_allocated_query(
    ::pg_query::Node* query) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(query_);
  }
  query_ = query;
  if (query) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CopyStmt.query)
}
inline ::pg_query::Node* CopyStmt::release_query() {
  
  ::pg_query::Node* temp = query_;
  query_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CopyStmt::unsafe_arena_release_query() {
  // @@protoc_insertion_point(field_release:pg_query.CopyStmt.query)
  
  ::pg_query::Node* temp = query_;
  query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CopyStmt::_internal_mutable_query() {
  
  if (query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    query_ = p;
  }
  return query_;
}
inline ::pg_query::Node* CopyStmt::mutable_query() {
  // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.query)
  return _internal_mutable_query();
}
inline void CopyStmt::set_allocated_query(::pg_query::Node* query) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete query_;
  }
  if (query) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(query);
    if (message_arena != submessage_arena) {
      query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, query, submessage_arena);
    }
    
  } else {
    
  }
  query_ = query;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CopyStmt.query)
}

// repeated .pg_query.Node attlist = 3 [json_name = "attlist"];
inline int CopyStmt::_internal_attlist_size() const {
  return attlist_.size();
}
inline int CopyStmt::attlist_size() const {
  return _internal_attlist_size();
}
inline void CopyStmt::clear_attlist() {
  attlist_.Clear();
}
inline ::pg_query::Node* CopyStmt::mutable_attlist(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.attlist)
  return attlist_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CopyStmt::mutable_attlist() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CopyStmt.attlist)
  return &attlist_;
}
inline const ::pg_query::Node& CopyStmt::_internal_attlist(int index) const {
  return attlist_.Get(index);
}
inline const ::pg_query::Node& CopyStmt::attlist(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.attlist)
  return _internal_attlist(index);
}
inline ::pg_query::Node* CopyStmt::_internal_add_attlist() {
  return attlist_.Add();
}
inline ::pg_query::Node* CopyStmt::add_attlist() {
  // @@protoc_insertion_point(field_add:pg_query.CopyStmt.attlist)
  return _internal_add_attlist();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CopyStmt::attlist() const {
  // @@protoc_insertion_point(field_list:pg_query.CopyStmt.attlist)
  return attlist_;
}

// bool is_from = 4 [json_name = "is_from"];
inline void CopyStmt::clear_is_from() {
  is_from_ = false;
}
inline bool CopyStmt::_internal_is_from() const {
  return is_from_;
}
inline bool CopyStmt::is_from() const {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.is_from)
  return _internal_is_from();
}
inline void CopyStmt::_internal_set_is_from(bool value) {
  
  is_from_ = value;
}
inline void CopyStmt::set_is_from(bool value) {
  _internal_set_is_from(value);
  // @@protoc_insertion_point(field_set:pg_query.CopyStmt.is_from)
}

// bool is_program = 5 [json_name = "is_program"];
inline void CopyStmt::clear_is_program() {
  is_program_ = false;
}
inline bool CopyStmt::_internal_is_program() const {
  return is_program_;
}
inline bool CopyStmt::is_program() const {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.is_program)
  return _internal_is_program();
}
inline void CopyStmt::_internal_set_is_program(bool value) {
  
  is_program_ = value;
}
inline void CopyStmt::set_is_program(bool value) {
  _internal_set_is_program(value);
  // @@protoc_insertion_point(field_set:pg_query.CopyStmt.is_program)
}

// string filename = 6 [json_name = "filename"];
inline void CopyStmt::clear_filename() {
  filename_.ClearToEmpty();
}
inline const std::string& CopyStmt::filename() const {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.filename)
  return _internal_filename();
}
inline void CopyStmt::set_filename(const std::string& value) {
  _internal_set_filename(value);
  // @@protoc_insertion_point(field_set:pg_query.CopyStmt.filename)
}
inline std::string* CopyStmt::mutable_filename() {
  // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.filename)
  return _internal_mutable_filename();
}
inline const std::string& CopyStmt::_internal_filename() const {
  return filename_.Get();
}
inline void CopyStmt::_internal_set_filename(const std::string& value) {
  
  filename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CopyStmt::set_filename(std::string&& value) {
  
  filename_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CopyStmt.filename)
}
inline void CopyStmt::set_filename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  filename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CopyStmt.filename)
}
inline void CopyStmt::set_filename(const char* value,
    size_t size) {
  
  filename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CopyStmt.filename)
}
inline std::string* CopyStmt::_internal_mutable_filename() {
  
  return filename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CopyStmt::release_filename() {
  // @@protoc_insertion_point(field_release:pg_query.CopyStmt.filename)
  return filename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CopyStmt::set_allocated_filename(std::string* filename) {
  if (filename != nullptr) {
    
  } else {
    
  }
  filename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), filename,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CopyStmt.filename)
}

// repeated .pg_query.Node options = 7 [json_name = "options"];
inline int CopyStmt::_internal_options_size() const {
  return options_.size();
}
inline int CopyStmt::options_size() const {
  return _internal_options_size();
}
inline void CopyStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CopyStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CopyStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CopyStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CopyStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CopyStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CopyStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CopyStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CopyStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CopyStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CopyStmt.options)
  return options_;
}

// .pg_query.Node where_clause = 8 [json_name = "whereClause"];
inline bool CopyStmt::_internal_has_where_clause() const {
  return this != internal_default_instance() && where_clause_ != nullptr;
}
inline bool CopyStmt::has_where_clause() const {
  return _internal_has_where_clause();
}
inline void CopyStmt::clear_where_clause() {
  if (GetArena() == nullptr && where_clause_ != nullptr) {
    delete where_clause_;
  }
  where_clause_ = nullptr;
}
inline const ::pg_query::Node& CopyStmt::_internal_where_clause() const {
  const ::pg_query::Node* p = where_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CopyStmt::where_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.where_clause)
  return _internal_where_clause();
}
inline void CopyStmt::unsafe_arena_set_allocated_where_clause(
    ::pg_query::Node* where_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(where_clause_);
  }
  where_clause_ = where_clause;
  if (where_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CopyStmt.where_clause)
}
inline ::pg_query::Node* CopyStmt::release_where_clause() {
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CopyStmt::unsafe_arena_release_where_clause() {
  // @@protoc_insertion_point(field_release:pg_query.CopyStmt.where_clause)
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CopyStmt::_internal_mutable_where_clause() {
  
  if (where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    where_clause_ = p;
  }
  return where_clause_;
}
inline ::pg_query::Node* CopyStmt::mutable_where_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.where_clause)
  return _internal_mutable_where_clause();
}
inline void CopyStmt::set_allocated_where_clause(::pg_query::Node* where_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete where_clause_;
  }
  if (where_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(where_clause);
    if (message_arena != submessage_arena) {
      where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, where_clause, submessage_arena);
    }
    
  } else {
    
  }
  where_clause_ = where_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CopyStmt.where_clause)
}

// -------------------------------------------------------------------

// CreateStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool CreateStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool CreateStmt::has_relation() const {
  return _internal_has_relation();
}
inline void CreateStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& CreateStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CreateStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.relation)
  return _internal_relation();
}
inline void CreateStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateStmt.relation)
}
inline ::pg_query::RangeVar* CreateStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* CreateStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.CreateStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CreateStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* CreateStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.relation)
  return _internal_mutable_relation();
}
inline void CreateStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStmt.relation)
}

// repeated .pg_query.Node table_elts = 2 [json_name = "tableElts"];
inline int CreateStmt::_internal_table_elts_size() const {
  return table_elts_.size();
}
inline int CreateStmt::table_elts_size() const {
  return _internal_table_elts_size();
}
inline void CreateStmt::clear_table_elts() {
  table_elts_.Clear();
}
inline ::pg_query::Node* CreateStmt::mutable_table_elts(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.table_elts)
  return table_elts_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateStmt::mutable_table_elts() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStmt.table_elts)
  return &table_elts_;
}
inline const ::pg_query::Node& CreateStmt::_internal_table_elts(int index) const {
  return table_elts_.Get(index);
}
inline const ::pg_query::Node& CreateStmt::table_elts(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.table_elts)
  return _internal_table_elts(index);
}
inline ::pg_query::Node* CreateStmt::_internal_add_table_elts() {
  return table_elts_.Add();
}
inline ::pg_query::Node* CreateStmt::add_table_elts() {
  // @@protoc_insertion_point(field_add:pg_query.CreateStmt.table_elts)
  return _internal_add_table_elts();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateStmt::table_elts() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateStmt.table_elts)
  return table_elts_;
}

// repeated .pg_query.Node inh_relations = 3 [json_name = "inhRelations"];
inline int CreateStmt::_internal_inh_relations_size() const {
  return inh_relations_.size();
}
inline int CreateStmt::inh_relations_size() const {
  return _internal_inh_relations_size();
}
inline void CreateStmt::clear_inh_relations() {
  inh_relations_.Clear();
}
inline ::pg_query::Node* CreateStmt::mutable_inh_relations(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.inh_relations)
  return inh_relations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateStmt::mutable_inh_relations() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStmt.inh_relations)
  return &inh_relations_;
}
inline const ::pg_query::Node& CreateStmt::_internal_inh_relations(int index) const {
  return inh_relations_.Get(index);
}
inline const ::pg_query::Node& CreateStmt::inh_relations(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.inh_relations)
  return _internal_inh_relations(index);
}
inline ::pg_query::Node* CreateStmt::_internal_add_inh_relations() {
  return inh_relations_.Add();
}
inline ::pg_query::Node* CreateStmt::add_inh_relations() {
  // @@protoc_insertion_point(field_add:pg_query.CreateStmt.inh_relations)
  return _internal_add_inh_relations();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateStmt::inh_relations() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateStmt.inh_relations)
  return inh_relations_;
}

// .pg_query.PartitionBoundSpec partbound = 4 [json_name = "partbound"];
inline bool CreateStmt::_internal_has_partbound() const {
  return this != internal_default_instance() && partbound_ != nullptr;
}
inline bool CreateStmt::has_partbound() const {
  return _internal_has_partbound();
}
inline void CreateStmt::clear_partbound() {
  if (GetArena() == nullptr && partbound_ != nullptr) {
    delete partbound_;
  }
  partbound_ = nullptr;
}
inline const ::pg_query::PartitionBoundSpec& CreateStmt::_internal_partbound() const {
  const ::pg_query::PartitionBoundSpec* p = partbound_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::PartitionBoundSpec&>(
      ::pg_query::_PartitionBoundSpec_default_instance_);
}
inline const ::pg_query::PartitionBoundSpec& CreateStmt::partbound() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.partbound)
  return _internal_partbound();
}
inline void CreateStmt::unsafe_arena_set_allocated_partbound(
    ::pg_query::PartitionBoundSpec* partbound) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(partbound_);
  }
  partbound_ = partbound;
  if (partbound) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateStmt.partbound)
}
inline ::pg_query::PartitionBoundSpec* CreateStmt::release_partbound() {
  
  ::pg_query::PartitionBoundSpec* temp = partbound_;
  partbound_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::PartitionBoundSpec* CreateStmt::unsafe_arena_release_partbound() {
  // @@protoc_insertion_point(field_release:pg_query.CreateStmt.partbound)
  
  ::pg_query::PartitionBoundSpec* temp = partbound_;
  partbound_ = nullptr;
  return temp;
}
inline ::pg_query::PartitionBoundSpec* CreateStmt::_internal_mutable_partbound() {
  
  if (partbound_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::PartitionBoundSpec>(GetArena());
    partbound_ = p;
  }
  return partbound_;
}
inline ::pg_query::PartitionBoundSpec* CreateStmt::mutable_partbound() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.partbound)
  return _internal_mutable_partbound();
}
inline void CreateStmt::set_allocated_partbound(::pg_query::PartitionBoundSpec* partbound) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete partbound_;
  }
  if (partbound) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(partbound);
    if (message_arena != submessage_arena) {
      partbound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, partbound, submessage_arena);
    }
    
  } else {
    
  }
  partbound_ = partbound;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStmt.partbound)
}

// .pg_query.PartitionSpec partspec = 5 [json_name = "partspec"];
inline bool CreateStmt::_internal_has_partspec() const {
  return this != internal_default_instance() && partspec_ != nullptr;
}
inline bool CreateStmt::has_partspec() const {
  return _internal_has_partspec();
}
inline void CreateStmt::clear_partspec() {
  if (GetArena() == nullptr && partspec_ != nullptr) {
    delete partspec_;
  }
  partspec_ = nullptr;
}
inline const ::pg_query::PartitionSpec& CreateStmt::_internal_partspec() const {
  const ::pg_query::PartitionSpec* p = partspec_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::PartitionSpec&>(
      ::pg_query::_PartitionSpec_default_instance_);
}
inline const ::pg_query::PartitionSpec& CreateStmt::partspec() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.partspec)
  return _internal_partspec();
}
inline void CreateStmt::unsafe_arena_set_allocated_partspec(
    ::pg_query::PartitionSpec* partspec) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(partspec_);
  }
  partspec_ = partspec;
  if (partspec) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateStmt.partspec)
}
inline ::pg_query::PartitionSpec* CreateStmt::release_partspec() {
  
  ::pg_query::PartitionSpec* temp = partspec_;
  partspec_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::PartitionSpec* CreateStmt::unsafe_arena_release_partspec() {
  // @@protoc_insertion_point(field_release:pg_query.CreateStmt.partspec)
  
  ::pg_query::PartitionSpec* temp = partspec_;
  partspec_ = nullptr;
  return temp;
}
inline ::pg_query::PartitionSpec* CreateStmt::_internal_mutable_partspec() {
  
  if (partspec_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::PartitionSpec>(GetArena());
    partspec_ = p;
  }
  return partspec_;
}
inline ::pg_query::PartitionSpec* CreateStmt::mutable_partspec() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.partspec)
  return _internal_mutable_partspec();
}
inline void CreateStmt::set_allocated_partspec(::pg_query::PartitionSpec* partspec) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete partspec_;
  }
  if (partspec) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(partspec);
    if (message_arena != submessage_arena) {
      partspec = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, partspec, submessage_arena);
    }
    
  } else {
    
  }
  partspec_ = partspec;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStmt.partspec)
}

// .pg_query.TypeName of_typename = 6 [json_name = "ofTypename"];
inline bool CreateStmt::_internal_has_of_typename() const {
  return this != internal_default_instance() && of_typename_ != nullptr;
}
inline bool CreateStmt::has_of_typename() const {
  return _internal_has_of_typename();
}
inline void CreateStmt::clear_of_typename() {
  if (GetArena() == nullptr && of_typename_ != nullptr) {
    delete of_typename_;
  }
  of_typename_ = nullptr;
}
inline const ::pg_query::TypeName& CreateStmt::_internal_of_typename() const {
  const ::pg_query::TypeName* p = of_typename_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(
      ::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& CreateStmt::of_typename() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.of_typename)
  return _internal_of_typename();
}
inline void CreateStmt::unsafe_arena_set_allocated_of_typename(
    ::pg_query::TypeName* of_typename) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(of_typename_);
  }
  of_typename_ = of_typename;
  if (of_typename) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateStmt.of_typename)
}
inline ::pg_query::TypeName* CreateStmt::release_of_typename() {
  
  ::pg_query::TypeName* temp = of_typename_;
  of_typename_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TypeName* CreateStmt::unsafe_arena_release_of_typename() {
  // @@protoc_insertion_point(field_release:pg_query.CreateStmt.of_typename)
  
  ::pg_query::TypeName* temp = of_typename_;
  of_typename_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateStmt::_internal_mutable_of_typename() {
  
  if (of_typename_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    of_typename_ = p;
  }
  return of_typename_;
}
inline ::pg_query::TypeName* CreateStmt::mutable_of_typename() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.of_typename)
  return _internal_mutable_of_typename();
}
inline void CreateStmt::set_allocated_of_typename(::pg_query::TypeName* of_typename) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete of_typename_;
  }
  if (of_typename) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(of_typename);
    if (message_arena != submessage_arena) {
      of_typename = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, of_typename, submessage_arena);
    }
    
  } else {
    
  }
  of_typename_ = of_typename;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStmt.of_typename)
}

// repeated .pg_query.Node constraints = 7 [json_name = "constraints"];
inline int CreateStmt::_internal_constraints_size() const {
  return constraints_.size();
}
inline int CreateStmt::constraints_size() const {
  return _internal_constraints_size();
}
inline void CreateStmt::clear_constraints() {
  constraints_.Clear();
}
inline ::pg_query::Node* CreateStmt::mutable_constraints(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.constraints)
  return constraints_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateStmt::mutable_constraints() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStmt.constraints)
  return &constraints_;
}
inline const ::pg_query::Node& CreateStmt::_internal_constraints(int index) const {
  return constraints_.Get(index);
}
inline const ::pg_query::Node& CreateStmt::constraints(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.constraints)
  return _internal_constraints(index);
}
inline ::pg_query::Node* CreateStmt::_internal_add_constraints() {
  return constraints_.Add();
}
inline ::pg_query::Node* CreateStmt::add_constraints() {
  // @@protoc_insertion_point(field_add:pg_query.CreateStmt.constraints)
  return _internal_add_constraints();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateStmt::constraints() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateStmt.constraints)
  return constraints_;
}

// repeated .pg_query.Node options = 8 [json_name = "options"];
inline int CreateStmt::_internal_options_size() const {
  return options_.size();
}
inline int CreateStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CreateStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CreateStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CreateStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CreateStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CreateStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreateStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateStmt.options)
  return options_;
}

// .pg_query.OnCommitAction oncommit = 9 [json_name = "oncommit"];
inline void CreateStmt::clear_oncommit() {
  oncommit_ = 0;
}
inline ::pg_query::OnCommitAction CreateStmt::_internal_oncommit() const {
  return static_cast< ::pg_query::OnCommitAction >(oncommit_);
}
inline ::pg_query::OnCommitAction CreateStmt::oncommit() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.oncommit)
  return _internal_oncommit();
}
inline void CreateStmt::_internal_set_oncommit(::pg_query::OnCommitAction value) {
  
  oncommit_ = value;
}
inline void CreateStmt::set_oncommit(::pg_query::OnCommitAction value) {
  _internal_set_oncommit(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateStmt.oncommit)
}

// string tablespacename = 10 [json_name = "tablespacename"];
inline void CreateStmt::clear_tablespacename() {
  tablespacename_.ClearToEmpty();
}
inline const std::string& CreateStmt::tablespacename() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.tablespacename)
  return _internal_tablespacename();
}
inline void CreateStmt::set_tablespacename(const std::string& value) {
  _internal_set_tablespacename(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateStmt.tablespacename)
}
inline std::string* CreateStmt::mutable_tablespacename() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.tablespacename)
  return _internal_mutable_tablespacename();
}
inline const std::string& CreateStmt::_internal_tablespacename() const {
  return tablespacename_.Get();
}
inline void CreateStmt::_internal_set_tablespacename(const std::string& value) {
  
  tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateStmt::set_tablespacename(std::string&& value) {
  
  tablespacename_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateStmt.tablespacename)
}
inline void CreateStmt::set_tablespacename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateStmt.tablespacename)
}
inline void CreateStmt::set_tablespacename(const char* value,
    size_t size) {
  
  tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateStmt.tablespacename)
}
inline std::string* CreateStmt::_internal_mutable_tablespacename() {
  
  return tablespacename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateStmt::release_tablespacename() {
  // @@protoc_insertion_point(field_release:pg_query.CreateStmt.tablespacename)
  return tablespacename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateStmt::set_allocated_tablespacename(std::string* tablespacename) {
  if (tablespacename != nullptr) {
    
  } else {
    
  }
  tablespacename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tablespacename,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStmt.tablespacename)
}

// string access_method = 11 [json_name = "accessMethod"];
inline void CreateStmt::clear_access_method() {
  access_method_.ClearToEmpty();
}
inline const std::string& CreateStmt::access_method() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.access_method)
  return _internal_access_method();
}
inline void CreateStmt::set_access_method(const std::string& value) {
  _internal_set_access_method(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateStmt.access_method)
}
inline std::string* CreateStmt::mutable_access_method() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.access_method)
  return _internal_mutable_access_method();
}
inline const std::string& CreateStmt::_internal_access_method() const {
  return access_method_.Get();
}
inline void CreateStmt::_internal_set_access_method(const std::string& value) {
  
  access_method_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateStmt::set_access_method(std::string&& value) {
  
  access_method_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateStmt.access_method)
}
inline void CreateStmt::set_access_method(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  access_method_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateStmt.access_method)
}
inline void CreateStmt::set_access_method(const char* value,
    size_t size) {
  
  access_method_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateStmt.access_method)
}
inline std::string* CreateStmt::_internal_mutable_access_method() {
  
  return access_method_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateStmt::release_access_method() {
  // @@protoc_insertion_point(field_release:pg_query.CreateStmt.access_method)
  return access_method_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateStmt::set_allocated_access_method(std::string* access_method) {
  if (access_method != nullptr) {
    
  } else {
    
  }
  access_method_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), access_method,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStmt.access_method)
}

// bool if_not_exists = 12 [json_name = "if_not_exists"];
inline void CreateStmt::clear_if_not_exists() {
  if_not_exists_ = false;
}
inline bool CreateStmt::_internal_if_not_exists() const {
  return if_not_exists_;
}
inline bool CreateStmt::if_not_exists() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.if_not_exists)
  return _internal_if_not_exists();
}
inline void CreateStmt::_internal_set_if_not_exists(bool value) {
  
  if_not_exists_ = value;
}
inline void CreateStmt::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateStmt.if_not_exists)
}

// -------------------------------------------------------------------

// DefineStmt

// .pg_query.ObjectType kind = 1 [json_name = "kind"];
inline void DefineStmt::clear_kind() {
  kind_ = 0;
}
inline ::pg_query::ObjectType DefineStmt::_internal_kind() const {
  return static_cast< ::pg_query::ObjectType >(kind_);
}
inline ::pg_query::ObjectType DefineStmt::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.DefineStmt.kind)
  return _internal_kind();
}
inline void DefineStmt::_internal_set_kind(::pg_query::ObjectType value) {
  
  kind_ = value;
}
inline void DefineStmt::set_kind(::pg_query::ObjectType value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.DefineStmt.kind)
}

// bool oldstyle = 2 [json_name = "oldstyle"];
inline void DefineStmt::clear_oldstyle() {
  oldstyle_ = false;
}
inline bool DefineStmt::_internal_oldstyle() const {
  return oldstyle_;
}
inline bool DefineStmt::oldstyle() const {
  // @@protoc_insertion_point(field_get:pg_query.DefineStmt.oldstyle)
  return _internal_oldstyle();
}
inline void DefineStmt::_internal_set_oldstyle(bool value) {
  
  oldstyle_ = value;
}
inline void DefineStmt::set_oldstyle(bool value) {
  _internal_set_oldstyle(value);
  // @@protoc_insertion_point(field_set:pg_query.DefineStmt.oldstyle)
}

// repeated .pg_query.Node defnames = 3 [json_name = "defnames"];
inline int DefineStmt::_internal_defnames_size() const {
  return defnames_.size();
}
inline int DefineStmt::defnames_size() const {
  return _internal_defnames_size();
}
inline void DefineStmt::clear_defnames() {
  defnames_.Clear();
}
inline ::pg_query::Node* DefineStmt::mutable_defnames(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.DefineStmt.defnames)
  return defnames_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
DefineStmt::mutable_defnames() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DefineStmt.defnames)
  return &defnames_;
}
inline const ::pg_query::Node& DefineStmt::_internal_defnames(int index) const {
  return defnames_.Get(index);
}
inline const ::pg_query::Node& DefineStmt::defnames(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.DefineStmt.defnames)
  return _internal_defnames(index);
}
inline ::pg_query::Node* DefineStmt::_internal_add_defnames() {
  return defnames_.Add();
}
inline ::pg_query::Node* DefineStmt::add_defnames() {
  // @@protoc_insertion_point(field_add:pg_query.DefineStmt.defnames)
  return _internal_add_defnames();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
DefineStmt::defnames() const {
  // @@protoc_insertion_point(field_list:pg_query.DefineStmt.defnames)
  return defnames_;
}

// repeated .pg_query.Node args = 4 [json_name = "args"];
inline int DefineStmt::_internal_args_size() const {
  return args_.size();
}
inline int DefineStmt::args_size() const {
  return _internal_args_size();
}
inline void DefineStmt::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* DefineStmt::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.DefineStmt.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
DefineStmt::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DefineStmt.args)
  return &args_;
}
inline const ::pg_query::Node& DefineStmt::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& DefineStmt::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.DefineStmt.args)
  return _internal_args(index);
}
inline ::pg_query::Node* DefineStmt::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* DefineStmt::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.DefineStmt.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
DefineStmt::args() const {
  // @@protoc_insertion_point(field_list:pg_query.DefineStmt.args)
  return args_;
}

// repeated .pg_query.Node definition = 5 [json_name = "definition"];
inline int DefineStmt::_internal_definition_size() const {
  return definition_.size();
}
inline int DefineStmt::definition_size() const {
  return _internal_definition_size();
}
inline void DefineStmt::clear_definition() {
  definition_.Clear();
}
inline ::pg_query::Node* DefineStmt::mutable_definition(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.DefineStmt.definition)
  return definition_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
DefineStmt::mutable_definition() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DefineStmt.definition)
  return &definition_;
}
inline const ::pg_query::Node& DefineStmt::_internal_definition(int index) const {
  return definition_.Get(index);
}
inline const ::pg_query::Node& DefineStmt::definition(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.DefineStmt.definition)
  return _internal_definition(index);
}
inline ::pg_query::Node* DefineStmt::_internal_add_definition() {
  return definition_.Add();
}
inline ::pg_query::Node* DefineStmt::add_definition() {
  // @@protoc_insertion_point(field_add:pg_query.DefineStmt.definition)
  return _internal_add_definition();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
DefineStmt::definition() const {
  // @@protoc_insertion_point(field_list:pg_query.DefineStmt.definition)
  return definition_;
}

// bool if_not_exists = 6 [json_name = "if_not_exists"];
inline void DefineStmt::clear_if_not_exists() {
  if_not_exists_ = false;
}
inline bool DefineStmt::_internal_if_not_exists() const {
  return if_not_exists_;
}
inline bool DefineStmt::if_not_exists() const {
  // @@protoc_insertion_point(field_get:pg_query.DefineStmt.if_not_exists)
  return _internal_if_not_exists();
}
inline void DefineStmt::_internal_set_if_not_exists(bool value) {
  
  if_not_exists_ = value;
}
inline void DefineStmt::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.DefineStmt.if_not_exists)
}

// bool replace = 7 [json_name = "replace"];
inline void DefineStmt::clear_replace() {
  replace_ = false;
}
inline bool DefineStmt::_internal_replace() const {
  return replace_;
}
inline bool DefineStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.DefineStmt.replace)
  return _internal_replace();
}
inline void DefineStmt::_internal_set_replace(bool value) {
  
  replace_ = value;
}
inline void DefineStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.DefineStmt.replace)
}

// -------------------------------------------------------------------

// DropStmt

// repeated .pg_query.Node objects = 1 [json_name = "objects"];
inline int DropStmt::_internal_objects_size() const {
  return objects_.size();
}
inline int DropStmt::objects_size() const {
  return _internal_objects_size();
}
inline void DropStmt::clear_objects() {
  objects_.Clear();
}
inline ::pg_query::Node* DropStmt::mutable_objects(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.DropStmt.objects)
  return objects_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
DropStmt::mutable_objects() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DropStmt.objects)
  return &objects_;
}
inline const ::pg_query::Node& DropStmt::_internal_objects(int index) const {
  return objects_.Get(index);
}
inline const ::pg_query::Node& DropStmt::objects(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.DropStmt.objects)
  return _internal_objects(index);
}
inline ::pg_query::Node* DropStmt::_internal_add_objects() {
  return objects_.Add();
}
inline ::pg_query::Node* DropStmt::add_objects() {
  // @@protoc_insertion_point(field_add:pg_query.DropStmt.objects)
  return _internal_add_objects();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
DropStmt::objects() const {
  // @@protoc_insertion_point(field_list:pg_query.DropStmt.objects)
  return objects_;
}

// .pg_query.ObjectType remove_type = 2 [json_name = "removeType"];
inline void DropStmt::clear_remove_type() {
  remove_type_ = 0;
}
inline ::pg_query::ObjectType DropStmt::_internal_remove_type() const {
  return static_cast< ::pg_query::ObjectType >(remove_type_);
}
inline ::pg_query::ObjectType DropStmt::remove_type() const {
  // @@protoc_insertion_point(field_get:pg_query.DropStmt.remove_type)
  return _internal_remove_type();
}
inline void DropStmt::_internal_set_remove_type(::pg_query::ObjectType value) {
  
  remove_type_ = value;
}
inline void DropStmt::set_remove_type(::pg_query::ObjectType value) {
  _internal_set_remove_type(value);
  // @@protoc_insertion_point(field_set:pg_query.DropStmt.remove_type)
}

// .pg_query.DropBehavior behavior = 3 [json_name = "behavior"];
inline void DropStmt::clear_behavior() {
  behavior_ = 0;
}
inline ::pg_query::DropBehavior DropStmt::_internal_behavior() const {
  return static_cast< ::pg_query::DropBehavior >(behavior_);
}
inline ::pg_query::DropBehavior DropStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.DropStmt.behavior)
  return _internal_behavior();
}
inline void DropStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  
  behavior_ = value;
}
inline void DropStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.DropStmt.behavior)
}

// bool missing_ok = 4 [json_name = "missing_ok"];
inline void DropStmt::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool DropStmt::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool DropStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.DropStmt.missing_ok)
  return _internal_missing_ok();
}
inline void DropStmt::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void DropStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.DropStmt.missing_ok)
}

// bool concurrent = 5 [json_name = "concurrent"];
inline void DropStmt::clear_concurrent() {
  concurrent_ = false;
}
inline bool DropStmt::_internal_concurrent() const {
  return concurrent_;
}
inline bool DropStmt::concurrent() const {
  // @@protoc_insertion_point(field_get:pg_query.DropStmt.concurrent)
  return _internal_concurrent();
}
inline void DropStmt::_internal_set_concurrent(bool value) {
  
  concurrent_ = value;
}
inline void DropStmt::set_concurrent(bool value) {
  _internal_set_concurrent(value);
  // @@protoc_insertion_point(field_set:pg_query.DropStmt.concurrent)
}

// -------------------------------------------------------------------

// TruncateStmt

// repeated .pg_query.Node relations = 1 [json_name = "relations"];
inline int TruncateStmt::_internal_relations_size() const {
  return relations_.size();
}
inline int TruncateStmt::relations_size() const {
  return _internal_relations_size();
}
inline void TruncateStmt::clear_relations() {
  relations_.Clear();
}
inline ::pg_query::Node* TruncateStmt::mutable_relations(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TruncateStmt.relations)
  return relations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TruncateStmt::mutable_relations() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TruncateStmt.relations)
  return &relations_;
}
inline const ::pg_query::Node& TruncateStmt::_internal_relations(int index) const {
  return relations_.Get(index);
}
inline const ::pg_query::Node& TruncateStmt::relations(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TruncateStmt.relations)
  return _internal_relations(index);
}
inline ::pg_query::Node* TruncateStmt::_internal_add_relations() {
  return relations_.Add();
}
inline ::pg_query::Node* TruncateStmt::add_relations() {
  // @@protoc_insertion_point(field_add:pg_query.TruncateStmt.relations)
  return _internal_add_relations();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TruncateStmt::relations() const {
  // @@protoc_insertion_point(field_list:pg_query.TruncateStmt.relations)
  return relations_;
}

// bool restart_seqs = 2 [json_name = "restart_seqs"];
inline void TruncateStmt::clear_restart_seqs() {
  restart_seqs_ = false;
}
inline bool TruncateStmt::_internal_restart_seqs() const {
  return restart_seqs_;
}
inline bool TruncateStmt::restart_seqs() const {
  // @@protoc_insertion_point(field_get:pg_query.TruncateStmt.restart_seqs)
  return _internal_restart_seqs();
}
inline void TruncateStmt::_internal_set_restart_seqs(bool value) {
  
  restart_seqs_ = value;
}
inline void TruncateStmt::set_restart_seqs(bool value) {
  _internal_set_restart_seqs(value);
  // @@protoc_insertion_point(field_set:pg_query.TruncateStmt.restart_seqs)
}

// .pg_query.DropBehavior behavior = 3 [json_name = "behavior"];
inline void TruncateStmt::clear_behavior() {
  behavior_ = 0;
}
inline ::pg_query::DropBehavior TruncateStmt::_internal_behavior() const {
  return static_cast< ::pg_query::DropBehavior >(behavior_);
}
inline ::pg_query::DropBehavior TruncateStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.TruncateStmt.behavior)
  return _internal_behavior();
}
inline void TruncateStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  
  behavior_ = value;
}
inline void TruncateStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.TruncateStmt.behavior)
}

// -------------------------------------------------------------------

// CommentStmt

// .pg_query.ObjectType objtype = 1 [json_name = "objtype"];
inline void CommentStmt::clear_objtype() {
  objtype_ = 0;
}
inline ::pg_query::ObjectType CommentStmt::_internal_objtype() const {
  return static_cast< ::pg_query::ObjectType >(objtype_);
}
inline ::pg_query::ObjectType CommentStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.CommentStmt.objtype)
  return _internal_objtype();
}
inline void CommentStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  
  objtype_ = value;
}
inline void CommentStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.CommentStmt.objtype)
}

// .pg_query.Node object = 2 [json_name = "object"];
inline bool CommentStmt::_internal_has_object() const {
  return this != internal_default_instance() && object_ != nullptr;
}
inline bool CommentStmt::has_object() const {
  return _internal_has_object();
}
inline void CommentStmt::clear_object() {
  if (GetArena() == nullptr && object_ != nullptr) {
    delete object_;
  }
  object_ = nullptr;
}
inline const ::pg_query::Node& CommentStmt::_internal_object() const {
  const ::pg_query::Node* p = object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CommentStmt::object() const {
  // @@protoc_insertion_point(field_get:pg_query.CommentStmt.object)
  return _internal_object();
}
inline void CommentStmt::unsafe_arena_set_allocated_object(
    ::pg_query::Node* object) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(object_);
  }
  object_ = object;
  if (object) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CommentStmt.object)
}
inline ::pg_query::Node* CommentStmt::release_object() {
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CommentStmt::unsafe_arena_release_object() {
  // @@protoc_insertion_point(field_release:pg_query.CommentStmt.object)
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CommentStmt::_internal_mutable_object() {
  
  if (object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    object_ = p;
  }
  return object_;
}
inline ::pg_query::Node* CommentStmt::mutable_object() {
  // @@protoc_insertion_point(field_mutable:pg_query.CommentStmt.object)
  return _internal_mutable_object();
}
inline void CommentStmt::set_allocated_object(::pg_query::Node* object) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete object_;
  }
  if (object) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(object);
    if (message_arena != submessage_arena) {
      object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, object, submessage_arena);
    }
    
  } else {
    
  }
  object_ = object;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CommentStmt.object)
}

// string comment = 3 [json_name = "comment"];
inline void CommentStmt::clear_comment() {
  comment_.ClearToEmpty();
}
inline const std::string& CommentStmt::comment() const {
  // @@protoc_insertion_point(field_get:pg_query.CommentStmt.comment)
  return _internal_comment();
}
inline void CommentStmt::set_comment(const std::string& value) {
  _internal_set_comment(value);
  // @@protoc_insertion_point(field_set:pg_query.CommentStmt.comment)
}
inline std::string* CommentStmt::mutable_comment() {
  // @@protoc_insertion_point(field_mutable:pg_query.CommentStmt.comment)
  return _internal_mutable_comment();
}
inline const std::string& CommentStmt::_internal_comment() const {
  return comment_.Get();
}
inline void CommentStmt::_internal_set_comment(const std::string& value) {
  
  comment_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CommentStmt::set_comment(std::string&& value) {
  
  comment_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CommentStmt.comment)
}
inline void CommentStmt::set_comment(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  comment_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CommentStmt.comment)
}
inline void CommentStmt::set_comment(const char* value,
    size_t size) {
  
  comment_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CommentStmt.comment)
}
inline std::string* CommentStmt::_internal_mutable_comment() {
  
  return comment_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CommentStmt::release_comment() {
  // @@protoc_insertion_point(field_release:pg_query.CommentStmt.comment)
  return comment_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CommentStmt::set_allocated_comment(std::string* comment) {
  if (comment != nullptr) {
    
  } else {
    
  }
  comment_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), comment,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CommentStmt.comment)
}

// -------------------------------------------------------------------

// FetchStmt

// .pg_query.FetchDirection direction = 1 [json_name = "direction"];
inline void FetchStmt::clear_direction() {
  direction_ = 0;
}
inline ::pg_query::FetchDirection FetchStmt::_internal_direction() const {
  return static_cast< ::pg_query::FetchDirection >(direction_);
}
inline ::pg_query::FetchDirection FetchStmt::direction() const {
  // @@protoc_insertion_point(field_get:pg_query.FetchStmt.direction)
  return _internal_direction();
}
inline void FetchStmt::_internal_set_direction(::pg_query::FetchDirection value) {
  
  direction_ = value;
}
inline void FetchStmt::set_direction(::pg_query::FetchDirection value) {
  _internal_set_direction(value);
  // @@protoc_insertion_point(field_set:pg_query.FetchStmt.direction)
}

// int64 how_many = 2 [json_name = "howMany"];
inline void FetchStmt::clear_how_many() {
  how_many_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 FetchStmt::_internal_how_many() const {
  return how_many_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 FetchStmt::how_many() const {
  // @@protoc_insertion_point(field_get:pg_query.FetchStmt.how_many)
  return _internal_how_many();
}
inline void FetchStmt::_internal_set_how_many(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  how_many_ = value;
}
inline void FetchStmt::set_how_many(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_how_many(value);
  // @@protoc_insertion_point(field_set:pg_query.FetchStmt.how_many)
}

// string portalname = 3 [json_name = "portalname"];
inline void FetchStmt::clear_portalname() {
  portalname_.ClearToEmpty();
}
inline const std::string& FetchStmt::portalname() const {
  // @@protoc_insertion_point(field_get:pg_query.FetchStmt.portalname)
  return _internal_portalname();
}
inline void FetchStmt::set_portalname(const std::string& value) {
  _internal_set_portalname(value);
  // @@protoc_insertion_point(field_set:pg_query.FetchStmt.portalname)
}
inline std::string* FetchStmt::mutable_portalname() {
  // @@protoc_insertion_point(field_mutable:pg_query.FetchStmt.portalname)
  return _internal_mutable_portalname();
}
inline const std::string& FetchStmt::_internal_portalname() const {
  return portalname_.Get();
}
inline void FetchStmt::_internal_set_portalname(const std::string& value) {
  
  portalname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FetchStmt::set_portalname(std::string&& value) {
  
  portalname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.FetchStmt.portalname)
}
inline void FetchStmt::set_portalname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  portalname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.FetchStmt.portalname)
}
inline void FetchStmt::set_portalname(const char* value,
    size_t size) {
  
  portalname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.FetchStmt.portalname)
}
inline std::string* FetchStmt::_internal_mutable_portalname() {
  
  return portalname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FetchStmt::release_portalname() {
  // @@protoc_insertion_point(field_release:pg_query.FetchStmt.portalname)
  return portalname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FetchStmt::set_allocated_portalname(std::string* portalname) {
  if (portalname != nullptr) {
    
  } else {
    
  }
  portalname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), portalname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.FetchStmt.portalname)
}

// bool ismove = 4 [json_name = "ismove"];
inline void FetchStmt::clear_ismove() {
  ismove_ = false;
}
inline bool FetchStmt::_internal_ismove() const {
  return ismove_;
}
inline bool FetchStmt::ismove() const {
  // @@protoc_insertion_point(field_get:pg_query.FetchStmt.ismove)
  return _internal_ismove();
}
inline void FetchStmt::_internal_set_ismove(bool value) {
  
  ismove_ = value;
}
inline void FetchStmt::set_ismove(bool value) {
  _internal_set_ismove(value);
  // @@protoc_insertion_point(field_set:pg_query.FetchStmt.ismove)
}

// -------------------------------------------------------------------

// IndexStmt

// string idxname = 1 [json_name = "idxname"];
inline void IndexStmt::clear_idxname() {
  idxname_.ClearToEmpty();
}
inline const std::string& IndexStmt::idxname() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.idxname)
  return _internal_idxname();
}
inline void IndexStmt::set_idxname(const std::string& value) {
  _internal_set_idxname(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.idxname)
}
inline std::string* IndexStmt::mutable_idxname() {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.idxname)
  return _internal_mutable_idxname();
}
inline const std::string& IndexStmt::_internal_idxname() const {
  return idxname_.Get();
}
inline void IndexStmt::_internal_set_idxname(const std::string& value) {
  
  idxname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void IndexStmt::set_idxname(std::string&& value) {
  
  idxname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.IndexStmt.idxname)
}
inline void IndexStmt::set_idxname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  idxname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.IndexStmt.idxname)
}
inline void IndexStmt::set_idxname(const char* value,
    size_t size) {
  
  idxname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.IndexStmt.idxname)
}
inline std::string* IndexStmt::_internal_mutable_idxname() {
  
  return idxname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* IndexStmt::release_idxname() {
  // @@protoc_insertion_point(field_release:pg_query.IndexStmt.idxname)
  return idxname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void IndexStmt::set_allocated_idxname(std::string* idxname) {
  if (idxname != nullptr) {
    
  } else {
    
  }
  idxname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), idxname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexStmt.idxname)
}

// .pg_query.RangeVar relation = 2 [json_name = "relation"];
inline bool IndexStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool IndexStmt::has_relation() const {
  return _internal_has_relation();
}
inline void IndexStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& IndexStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& IndexStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.relation)
  return _internal_relation();
}
inline void IndexStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IndexStmt.relation)
}
inline ::pg_query::RangeVar* IndexStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* IndexStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.IndexStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* IndexStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* IndexStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.relation)
  return _internal_mutable_relation();
}
inline void IndexStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexStmt.relation)
}

// string access_method = 3 [json_name = "accessMethod"];
inline void IndexStmt::clear_access_method() {
  access_method_.ClearToEmpty();
}
inline const std::string& IndexStmt::access_method() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.access_method)
  return _internal_access_method();
}
inline void IndexStmt::set_access_method(const std::string& value) {
  _internal_set_access_method(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.access_method)
}
inline std::string* IndexStmt::mutable_access_method() {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.access_method)
  return _internal_mutable_access_method();
}
inline const std::string& IndexStmt::_internal_access_method() const {
  return access_method_.Get();
}
inline void IndexStmt::_internal_set_access_method(const std::string& value) {
  
  access_method_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void IndexStmt::set_access_method(std::string&& value) {
  
  access_method_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.IndexStmt.access_method)
}
inline void IndexStmt::set_access_method(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  access_method_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.IndexStmt.access_method)
}
inline void IndexStmt::set_access_method(const char* value,
    size_t size) {
  
  access_method_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.IndexStmt.access_method)
}
inline std::string* IndexStmt::_internal_mutable_access_method() {
  
  return access_method_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* IndexStmt::release_access_method() {
  // @@protoc_insertion_point(field_release:pg_query.IndexStmt.access_method)
  return access_method_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void IndexStmt::set_allocated_access_method(std::string* access_method) {
  if (access_method != nullptr) {
    
  } else {
    
  }
  access_method_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), access_method,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexStmt.access_method)
}

// string table_space = 4 [json_name = "tableSpace"];
inline void IndexStmt::clear_table_space() {
  table_space_.ClearToEmpty();
}
inline const std::string& IndexStmt::table_space() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.table_space)
  return _internal_table_space();
}
inline void IndexStmt::set_table_space(const std::string& value) {
  _internal_set_table_space(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.table_space)
}
inline std::string* IndexStmt::mutable_table_space() {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.table_space)
  return _internal_mutable_table_space();
}
inline const std::string& IndexStmt::_internal_table_space() const {
  return table_space_.Get();
}
inline void IndexStmt::_internal_set_table_space(const std::string& value) {
  
  table_space_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void IndexStmt::set_table_space(std::string&& value) {
  
  table_space_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.IndexStmt.table_space)
}
inline void IndexStmt::set_table_space(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  table_space_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.IndexStmt.table_space)
}
inline void IndexStmt::set_table_space(const char* value,
    size_t size) {
  
  table_space_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.IndexStmt.table_space)
}
inline std::string* IndexStmt::_internal_mutable_table_space() {
  
  return table_space_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* IndexStmt::release_table_space() {
  // @@protoc_insertion_point(field_release:pg_query.IndexStmt.table_space)
  return table_space_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void IndexStmt::set_allocated_table_space(std::string* table_space) {
  if (table_space != nullptr) {
    
  } else {
    
  }
  table_space_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_space,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexStmt.table_space)
}

// repeated .pg_query.Node index_params = 5 [json_name = "indexParams"];
inline int IndexStmt::_internal_index_params_size() const {
  return index_params_.size();
}
inline int IndexStmt::index_params_size() const {
  return _internal_index_params_size();
}
inline void IndexStmt::clear_index_params() {
  index_params_.Clear();
}
inline ::pg_query::Node* IndexStmt::mutable_index_params(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.index_params)
  return index_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
IndexStmt::mutable_index_params() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexStmt.index_params)
  return &index_params_;
}
inline const ::pg_query::Node& IndexStmt::_internal_index_params(int index) const {
  return index_params_.Get(index);
}
inline const ::pg_query::Node& IndexStmt::index_params(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.index_params)
  return _internal_index_params(index);
}
inline ::pg_query::Node* IndexStmt::_internal_add_index_params() {
  return index_params_.Add();
}
inline ::pg_query::Node* IndexStmt::add_index_params() {
  // @@protoc_insertion_point(field_add:pg_query.IndexStmt.index_params)
  return _internal_add_index_params();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
IndexStmt::index_params() const {
  // @@protoc_insertion_point(field_list:pg_query.IndexStmt.index_params)
  return index_params_;
}

// repeated .pg_query.Node index_including_params = 6 [json_name = "indexIncludingParams"];
inline int IndexStmt::_internal_index_including_params_size() const {
  return index_including_params_.size();
}
inline int IndexStmt::index_including_params_size() const {
  return _internal_index_including_params_size();
}
inline void IndexStmt::clear_index_including_params() {
  index_including_params_.Clear();
}
inline ::pg_query::Node* IndexStmt::mutable_index_including_params(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.index_including_params)
  return index_including_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
IndexStmt::mutable_index_including_params() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexStmt.index_including_params)
  return &index_including_params_;
}
inline const ::pg_query::Node& IndexStmt::_internal_index_including_params(int index) const {
  return index_including_params_.Get(index);
}
inline const ::pg_query::Node& IndexStmt::index_including_params(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.index_including_params)
  return _internal_index_including_params(index);
}
inline ::pg_query::Node* IndexStmt::_internal_add_index_including_params() {
  return index_including_params_.Add();
}
inline ::pg_query::Node* IndexStmt::add_index_including_params() {
  // @@protoc_insertion_point(field_add:pg_query.IndexStmt.index_including_params)
  return _internal_add_index_including_params();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
IndexStmt::index_including_params() const {
  // @@protoc_insertion_point(field_list:pg_query.IndexStmt.index_including_params)
  return index_including_params_;
}

// repeated .pg_query.Node options = 7 [json_name = "options"];
inline int IndexStmt::_internal_options_size() const {
  return options_.size();
}
inline int IndexStmt::options_size() const {
  return _internal_options_size();
}
inline void IndexStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* IndexStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
IndexStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexStmt.options)
  return &options_;
}
inline const ::pg_query::Node& IndexStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& IndexStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* IndexStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* IndexStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.IndexStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
IndexStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.IndexStmt.options)
  return options_;
}

// .pg_query.Node where_clause = 8 [json_name = "whereClause"];
inline bool IndexStmt::_internal_has_where_clause() const {
  return this != internal_default_instance() && where_clause_ != nullptr;
}
inline bool IndexStmt::has_where_clause() const {
  return _internal_has_where_clause();
}
inline void IndexStmt::clear_where_clause() {
  if (GetArena() == nullptr && where_clause_ != nullptr) {
    delete where_clause_;
  }
  where_clause_ = nullptr;
}
inline const ::pg_query::Node& IndexStmt::_internal_where_clause() const {
  const ::pg_query::Node* p = where_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& IndexStmt::where_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.where_clause)
  return _internal_where_clause();
}
inline void IndexStmt::unsafe_arena_set_allocated_where_clause(
    ::pg_query::Node* where_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(where_clause_);
  }
  where_clause_ = where_clause;
  if (where_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IndexStmt.where_clause)
}
inline ::pg_query::Node* IndexStmt::release_where_clause() {
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* IndexStmt::unsafe_arena_release_where_clause() {
  // @@protoc_insertion_point(field_release:pg_query.IndexStmt.where_clause)
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* IndexStmt::_internal_mutable_where_clause() {
  
  if (where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    where_clause_ = p;
  }
  return where_clause_;
}
inline ::pg_query::Node* IndexStmt::mutable_where_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.where_clause)
  return _internal_mutable_where_clause();
}
inline void IndexStmt::set_allocated_where_clause(::pg_query::Node* where_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete where_clause_;
  }
  if (where_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(where_clause);
    if (message_arena != submessage_arena) {
      where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, where_clause, submessage_arena);
    }
    
  } else {
    
  }
  where_clause_ = where_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexStmt.where_clause)
}

// repeated .pg_query.Node exclude_op_names = 9 [json_name = "excludeOpNames"];
inline int IndexStmt::_internal_exclude_op_names_size() const {
  return exclude_op_names_.size();
}
inline int IndexStmt::exclude_op_names_size() const {
  return _internal_exclude_op_names_size();
}
inline void IndexStmt::clear_exclude_op_names() {
  exclude_op_names_.Clear();
}
inline ::pg_query::Node* IndexStmt::mutable_exclude_op_names(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.exclude_op_names)
  return exclude_op_names_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
IndexStmt::mutable_exclude_op_names() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexStmt.exclude_op_names)
  return &exclude_op_names_;
}
inline const ::pg_query::Node& IndexStmt::_internal_exclude_op_names(int index) const {
  return exclude_op_names_.Get(index);
}
inline const ::pg_query::Node& IndexStmt::exclude_op_names(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.exclude_op_names)
  return _internal_exclude_op_names(index);
}
inline ::pg_query::Node* IndexStmt::_internal_add_exclude_op_names() {
  return exclude_op_names_.Add();
}
inline ::pg_query::Node* IndexStmt::add_exclude_op_names() {
  // @@protoc_insertion_point(field_add:pg_query.IndexStmt.exclude_op_names)
  return _internal_add_exclude_op_names();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
IndexStmt::exclude_op_names() const {
  // @@protoc_insertion_point(field_list:pg_query.IndexStmt.exclude_op_names)
  return exclude_op_names_;
}

// string idxcomment = 10 [json_name = "idxcomment"];
inline void IndexStmt::clear_idxcomment() {
  idxcomment_.ClearToEmpty();
}
inline const std::string& IndexStmt::idxcomment() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.idxcomment)
  return _internal_idxcomment();
}
inline void IndexStmt::set_idxcomment(const std::string& value) {
  _internal_set_idxcomment(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.idxcomment)
}
inline std::string* IndexStmt::mutable_idxcomment() {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.idxcomment)
  return _internal_mutable_idxcomment();
}
inline const std::string& IndexStmt::_internal_idxcomment() const {
  return idxcomment_.Get();
}
inline void IndexStmt::_internal_set_idxcomment(const std::string& value) {
  
  idxcomment_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void IndexStmt::set_idxcomment(std::string&& value) {
  
  idxcomment_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.IndexStmt.idxcomment)
}
inline void IndexStmt::set_idxcomment(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  idxcomment_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.IndexStmt.idxcomment)
}
inline void IndexStmt::set_idxcomment(const char* value,
    size_t size) {
  
  idxcomment_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.IndexStmt.idxcomment)
}
inline std::string* IndexStmt::_internal_mutable_idxcomment() {
  
  return idxcomment_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* IndexStmt::release_idxcomment() {
  // @@protoc_insertion_point(field_release:pg_query.IndexStmt.idxcomment)
  return idxcomment_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void IndexStmt::set_allocated_idxcomment(std::string* idxcomment) {
  if (idxcomment != nullptr) {
    
  } else {
    
  }
  idxcomment_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), idxcomment,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexStmt.idxcomment)
}

// uint32 index_oid = 11 [json_name = "indexOid"];
inline void IndexStmt::clear_index_oid() {
  index_oid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 IndexStmt::_internal_index_oid() const {
  return index_oid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 IndexStmt::index_oid() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.index_oid)
  return _internal_index_oid();
}
inline void IndexStmt::_internal_set_index_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  index_oid_ = value;
}
inline void IndexStmt::set_index_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_index_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.index_oid)
}

// uint32 old_node = 12 [json_name = "oldNode"];
inline void IndexStmt::clear_old_node() {
  old_node_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 IndexStmt::_internal_old_node() const {
  return old_node_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 IndexStmt::old_node() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.old_node)
  return _internal_old_node();
}
inline void IndexStmt::_internal_set_old_node(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  old_node_ = value;
}
inline void IndexStmt::set_old_node(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_old_node(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.old_node)
}

// uint32 old_create_subid = 13 [json_name = "oldCreateSubid"];
inline void IndexStmt::clear_old_create_subid() {
  old_create_subid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 IndexStmt::_internal_old_create_subid() const {
  return old_create_subid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 IndexStmt::old_create_subid() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.old_create_subid)
  return _internal_old_create_subid();
}
inline void IndexStmt::_internal_set_old_create_subid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  old_create_subid_ = value;
}
inline void IndexStmt::set_old_create_subid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_old_create_subid(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.old_create_subid)
}

// uint32 old_first_relfilenode_subid = 14 [json_name = "oldFirstRelfilenodeSubid"];
inline void IndexStmt::clear_old_first_relfilenode_subid() {
  old_first_relfilenode_subid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 IndexStmt::_internal_old_first_relfilenode_subid() const {
  return old_first_relfilenode_subid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 IndexStmt::old_first_relfilenode_subid() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.old_first_relfilenode_subid)
  return _internal_old_first_relfilenode_subid();
}
inline void IndexStmt::_internal_set_old_first_relfilenode_subid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  old_first_relfilenode_subid_ = value;
}
inline void IndexStmt::set_old_first_relfilenode_subid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_old_first_relfilenode_subid(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.old_first_relfilenode_subid)
}

// bool unique = 15 [json_name = "unique"];
inline void IndexStmt::clear_unique() {
  unique_ = false;
}
inline bool IndexStmt::_internal_unique() const {
  return unique_;
}
inline bool IndexStmt::unique() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.unique)
  return _internal_unique();
}
inline void IndexStmt::_internal_set_unique(bool value) {
  
  unique_ = value;
}
inline void IndexStmt::set_unique(bool value) {
  _internal_set_unique(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.unique)
}

// bool primary = 16 [json_name = "primary"];
inline void IndexStmt::clear_primary() {
  primary_ = false;
}
inline bool IndexStmt::_internal_primary() const {
  return primary_;
}
inline bool IndexStmt::primary() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.primary)
  return _internal_primary();
}
inline void IndexStmt::_internal_set_primary(bool value) {
  
  primary_ = value;
}
inline void IndexStmt::set_primary(bool value) {
  _internal_set_primary(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.primary)
}

// bool isconstraint = 17 [json_name = "isconstraint"];
inline void IndexStmt::clear_isconstraint() {
  isconstraint_ = false;
}
inline bool IndexStmt::_internal_isconstraint() const {
  return isconstraint_;
}
inline bool IndexStmt::isconstraint() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.isconstraint)
  return _internal_isconstraint();
}
inline void IndexStmt::_internal_set_isconstraint(bool value) {
  
  isconstraint_ = value;
}
inline void IndexStmt::set_isconstraint(bool value) {
  _internal_set_isconstraint(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.isconstraint)
}

// bool deferrable = 18 [json_name = "deferrable"];
inline void IndexStmt::clear_deferrable() {
  deferrable_ = false;
}
inline bool IndexStmt::_internal_deferrable() const {
  return deferrable_;
}
inline bool IndexStmt::deferrable() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.deferrable)
  return _internal_deferrable();
}
inline void IndexStmt::_internal_set_deferrable(bool value) {
  
  deferrable_ = value;
}
inline void IndexStmt::set_deferrable(bool value) {
  _internal_set_deferrable(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.deferrable)
}

// bool initdeferred = 19 [json_name = "initdeferred"];
inline void IndexStmt::clear_initdeferred() {
  initdeferred_ = false;
}
inline bool IndexStmt::_internal_initdeferred() const {
  return initdeferred_;
}
inline bool IndexStmt::initdeferred() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.initdeferred)
  return _internal_initdeferred();
}
inline void IndexStmt::_internal_set_initdeferred(bool value) {
  
  initdeferred_ = value;
}
inline void IndexStmt::set_initdeferred(bool value) {
  _internal_set_initdeferred(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.initdeferred)
}

// bool transformed = 20 [json_name = "transformed"];
inline void IndexStmt::clear_transformed() {
  transformed_ = false;
}
inline bool IndexStmt::_internal_transformed() const {
  return transformed_;
}
inline bool IndexStmt::transformed() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.transformed)
  return _internal_transformed();
}
inline void IndexStmt::_internal_set_transformed(bool value) {
  
  transformed_ = value;
}
inline void IndexStmt::set_transformed(bool value) {
  _internal_set_transformed(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.transformed)
}

// bool concurrent = 21 [json_name = "concurrent"];
inline void IndexStmt::clear_concurrent() {
  concurrent_ = false;
}
inline bool IndexStmt::_internal_concurrent() const {
  return concurrent_;
}
inline bool IndexStmt::concurrent() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.concurrent)
  return _internal_concurrent();
}
inline void IndexStmt::_internal_set_concurrent(bool value) {
  
  concurrent_ = value;
}
inline void IndexStmt::set_concurrent(bool value) {
  _internal_set_concurrent(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.concurrent)
}

// bool if_not_exists = 22 [json_name = "if_not_exists"];
inline void IndexStmt::clear_if_not_exists() {
  if_not_exists_ = false;
}
inline bool IndexStmt::_internal_if_not_exists() const {
  return if_not_exists_;
}
inline bool IndexStmt::if_not_exists() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.if_not_exists)
  return _internal_if_not_exists();
}
inline void IndexStmt::_internal_set_if_not_exists(bool value) {
  
  if_not_exists_ = value;
}
inline void IndexStmt::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.if_not_exists)
}

// bool reset_default_tblspc = 23 [json_name = "reset_default_tblspc"];
inline void IndexStmt::clear_reset_default_tblspc() {
  reset_default_tblspc_ = false;
}
inline bool IndexStmt::_internal_reset_default_tblspc() const {
  return reset_default_tblspc_;
}
inline bool IndexStmt::reset_default_tblspc() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.reset_default_tblspc)
  return _internal_reset_default_tblspc();
}
inline void IndexStmt::_internal_set_reset_default_tblspc(bool value) {
  
  reset_default_tblspc_ = value;
}
inline void IndexStmt::set_reset_default_tblspc(bool value) {
  _internal_set_reset_default_tblspc(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.reset_default_tblspc)
}

// -------------------------------------------------------------------

// CreateFunctionStmt

// bool is_procedure = 1 [json_name = "is_procedure"];
inline void CreateFunctionStmt::clear_is_procedure() {
  is_procedure_ = false;
}
inline bool CreateFunctionStmt::_internal_is_procedure() const {
  return is_procedure_;
}
inline bool CreateFunctionStmt::is_procedure() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.is_procedure)
  return _internal_is_procedure();
}
inline void CreateFunctionStmt::_internal_set_is_procedure(bool value) {
  
  is_procedure_ = value;
}
inline void CreateFunctionStmt::set_is_procedure(bool value) {
  _internal_set_is_procedure(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateFunctionStmt.is_procedure)
}

// bool replace = 2 [json_name = "replace"];
inline void CreateFunctionStmt::clear_replace() {
  replace_ = false;
}
inline bool CreateFunctionStmt::_internal_replace() const {
  return replace_;
}
inline bool CreateFunctionStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.replace)
  return _internal_replace();
}
inline void CreateFunctionStmt::_internal_set_replace(bool value) {
  
  replace_ = value;
}
inline void CreateFunctionStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateFunctionStmt.replace)
}

// repeated .pg_query.Node funcname = 3 [json_name = "funcname"];
inline int CreateFunctionStmt::_internal_funcname_size() const {
  return funcname_.size();
}
inline int CreateFunctionStmt::funcname_size() const {
  return _internal_funcname_size();
}
inline void CreateFunctionStmt::clear_funcname() {
  funcname_.Clear();
}
inline ::pg_query::Node* CreateFunctionStmt::mutable_funcname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFunctionStmt.funcname)
  return funcname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateFunctionStmt::mutable_funcname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFunctionStmt.funcname)
  return &funcname_;
}
inline const ::pg_query::Node& CreateFunctionStmt::_internal_funcname(int index) const {
  return funcname_.Get(index);
}
inline const ::pg_query::Node& CreateFunctionStmt::funcname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.funcname)
  return _internal_funcname(index);
}
inline ::pg_query::Node* CreateFunctionStmt::_internal_add_funcname() {
  return funcname_.Add();
}
inline ::pg_query::Node* CreateFunctionStmt::add_funcname() {
  // @@protoc_insertion_point(field_add:pg_query.CreateFunctionStmt.funcname)
  return _internal_add_funcname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateFunctionStmt::funcname() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateFunctionStmt.funcname)
  return funcname_;
}

// repeated .pg_query.Node parameters = 4 [json_name = "parameters"];
inline int CreateFunctionStmt::_internal_parameters_size() const {
  return parameters_.size();
}
inline int CreateFunctionStmt::parameters_size() const {
  return _internal_parameters_size();
}
inline void CreateFunctionStmt::clear_parameters() {
  parameters_.Clear();
}
inline ::pg_query::Node* CreateFunctionStmt::mutable_parameters(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFunctionStmt.parameters)
  return parameters_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateFunctionStmt::mutable_parameters() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFunctionStmt.parameters)
  return &parameters_;
}
inline const ::pg_query::Node& CreateFunctionStmt::_internal_parameters(int index) const {
  return parameters_.Get(index);
}
inline const ::pg_query::Node& CreateFunctionStmt::parameters(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.parameters)
  return _internal_parameters(index);
}
inline ::pg_query::Node* CreateFunctionStmt::_internal_add_parameters() {
  return parameters_.Add();
}
inline ::pg_query::Node* CreateFunctionStmt::add_parameters() {
  // @@protoc_insertion_point(field_add:pg_query.CreateFunctionStmt.parameters)
  return _internal_add_parameters();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateFunctionStmt::parameters() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateFunctionStmt.parameters)
  return parameters_;
}

// .pg_query.TypeName return_type = 5 [json_name = "returnType"];
inline bool CreateFunctionStmt::_internal_has_return_type() const {
  return this != internal_default_instance() && return_type_ != nullptr;
}
inline bool CreateFunctionStmt::has_return_type() const {
  return _internal_has_return_type();
}
inline void CreateFunctionStmt::clear_return_type() {
  if (GetArena() == nullptr && return_type_ != nullptr) {
    delete return_type_;
  }
  return_type_ = nullptr;
}
inline const ::pg_query::TypeName& CreateFunctionStmt::_internal_return_type() const {
  const ::pg_query::TypeName* p = return_type_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(
      ::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& CreateFunctionStmt::return_type() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.return_type)
  return _internal_return_type();
}
inline void CreateFunctionStmt::unsafe_arena_set_allocated_return_type(
    ::pg_query::TypeName* return_type) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(return_type_);
  }
  return_type_ = return_type;
  if (return_type) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateFunctionStmt.return_type)
}
inline ::pg_query::TypeName* CreateFunctionStmt::release_return_type() {
  
  ::pg_query::TypeName* temp = return_type_;
  return_type_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TypeName* CreateFunctionStmt::unsafe_arena_release_return_type() {
  // @@protoc_insertion_point(field_release:pg_query.CreateFunctionStmt.return_type)
  
  ::pg_query::TypeName* temp = return_type_;
  return_type_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateFunctionStmt::_internal_mutable_return_type() {
  
  if (return_type_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    return_type_ = p;
  }
  return return_type_;
}
inline ::pg_query::TypeName* CreateFunctionStmt::mutable_return_type() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFunctionStmt.return_type)
  return _internal_mutable_return_type();
}
inline void CreateFunctionStmt::set_allocated_return_type(::pg_query::TypeName* return_type) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete return_type_;
  }
  if (return_type) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(return_type);
    if (message_arena != submessage_arena) {
      return_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, return_type, submessage_arena);
    }
    
  } else {
    
  }
  return_type_ = return_type;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateFunctionStmt.return_type)
}

// repeated .pg_query.Node options = 6 [json_name = "options"];
inline int CreateFunctionStmt::_internal_options_size() const {
  return options_.size();
}
inline int CreateFunctionStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateFunctionStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CreateFunctionStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFunctionStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateFunctionStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFunctionStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CreateFunctionStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CreateFunctionStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CreateFunctionStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CreateFunctionStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreateFunctionStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateFunctionStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateFunctionStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// AlterFunctionStmt

// .pg_query.ObjectType objtype = 1 [json_name = "objtype"];
inline void AlterFunctionStmt::clear_objtype() {
  objtype_ = 0;
}
inline ::pg_query::ObjectType AlterFunctionStmt::_internal_objtype() const {
  return static_cast< ::pg_query::ObjectType >(objtype_);
}
inline ::pg_query::ObjectType AlterFunctionStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterFunctionStmt.objtype)
  return _internal_objtype();
}
inline void AlterFunctionStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  
  objtype_ = value;
}
inline void AlterFunctionStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterFunctionStmt.objtype)
}

// .pg_query.ObjectWithArgs func = 2 [json_name = "func"];
inline bool AlterFunctionStmt::_internal_has_func() const {
  return this != internal_default_instance() && func_ != nullptr;
}
inline bool AlterFunctionStmt::has_func() const {
  return _internal_has_func();
}
inline void AlterFunctionStmt::clear_func() {
  if (GetArena() == nullptr && func_ != nullptr) {
    delete func_;
  }
  func_ = nullptr;
}
inline const ::pg_query::ObjectWithArgs& AlterFunctionStmt::_internal_func() const {
  const ::pg_query::ObjectWithArgs* p = func_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::ObjectWithArgs&>(
      ::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& AlterFunctionStmt::func() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterFunctionStmt.func)
  return _internal_func();
}
inline void AlterFunctionStmt::unsafe_arena_set_allocated_func(
    ::pg_query::ObjectWithArgs* func) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(func_);
  }
  func_ = func;
  if (func) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterFunctionStmt.func)
}
inline ::pg_query::ObjectWithArgs* AlterFunctionStmt::release_func() {
  
  ::pg_query::ObjectWithArgs* temp = func_;
  func_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::ObjectWithArgs* AlterFunctionStmt::unsafe_arena_release_func() {
  // @@protoc_insertion_point(field_release:pg_query.AlterFunctionStmt.func)
  
  ::pg_query::ObjectWithArgs* temp = func_;
  func_ = nullptr;
  return temp;
}
inline ::pg_query::ObjectWithArgs* AlterFunctionStmt::_internal_mutable_func() {
  
  if (func_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArena());
    func_ = p;
  }
  return func_;
}
inline ::pg_query::ObjectWithArgs* AlterFunctionStmt::mutable_func() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterFunctionStmt.func)
  return _internal_mutable_func();
}
inline void AlterFunctionStmt::set_allocated_func(::pg_query::ObjectWithArgs* func) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete func_;
  }
  if (func) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(func);
    if (message_arena != submessage_arena) {
      func = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, func, submessage_arena);
    }
    
  } else {
    
  }
  func_ = func;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterFunctionStmt.func)
}

// repeated .pg_query.Node actions = 3 [json_name = "actions"];
inline int AlterFunctionStmt::_internal_actions_size() const {
  return actions_.size();
}
inline int AlterFunctionStmt::actions_size() const {
  return _internal_actions_size();
}
inline void AlterFunctionStmt::clear_actions() {
  actions_.Clear();
}
inline ::pg_query::Node* AlterFunctionStmt::mutable_actions(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterFunctionStmt.actions)
  return actions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterFunctionStmt::mutable_actions() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterFunctionStmt.actions)
  return &actions_;
}
inline const ::pg_query::Node& AlterFunctionStmt::_internal_actions(int index) const {
  return actions_.Get(index);
}
inline const ::pg_query::Node& AlterFunctionStmt::actions(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterFunctionStmt.actions)
  return _internal_actions(index);
}
inline ::pg_query::Node* AlterFunctionStmt::_internal_add_actions() {
  return actions_.Add();
}
inline ::pg_query::Node* AlterFunctionStmt::add_actions() {
  // @@protoc_insertion_point(field_add:pg_query.AlterFunctionStmt.actions)
  return _internal_add_actions();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterFunctionStmt::actions() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterFunctionStmt.actions)
  return actions_;
}

// -------------------------------------------------------------------

// DoStmt

// repeated .pg_query.Node args = 1 [json_name = "args"];
inline int DoStmt::_internal_args_size() const {
  return args_.size();
}
inline int DoStmt::args_size() const {
  return _internal_args_size();
}
inline void DoStmt::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* DoStmt::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.DoStmt.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
DoStmt::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DoStmt.args)
  return &args_;
}
inline const ::pg_query::Node& DoStmt::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& DoStmt::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.DoStmt.args)
  return _internal_args(index);
}
inline ::pg_query::Node* DoStmt::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* DoStmt::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.DoStmt.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
DoStmt::args() const {
  // @@protoc_insertion_point(field_list:pg_query.DoStmt.args)
  return args_;
}

// -------------------------------------------------------------------

// RenameStmt

// .pg_query.ObjectType rename_type = 1 [json_name = "renameType"];
inline void RenameStmt::clear_rename_type() {
  rename_type_ = 0;
}
inline ::pg_query::ObjectType RenameStmt::_internal_rename_type() const {
  return static_cast< ::pg_query::ObjectType >(rename_type_);
}
inline ::pg_query::ObjectType RenameStmt::rename_type() const {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.rename_type)
  return _internal_rename_type();
}
inline void RenameStmt::_internal_set_rename_type(::pg_query::ObjectType value) {
  
  rename_type_ = value;
}
inline void RenameStmt::set_rename_type(::pg_query::ObjectType value) {
  _internal_set_rename_type(value);
  // @@protoc_insertion_point(field_set:pg_query.RenameStmt.rename_type)
}

// .pg_query.ObjectType relation_type = 2 [json_name = "relationType"];
inline void RenameStmt::clear_relation_type() {
  relation_type_ = 0;
}
inline ::pg_query::ObjectType RenameStmt::_internal_relation_type() const {
  return static_cast< ::pg_query::ObjectType >(relation_type_);
}
inline ::pg_query::ObjectType RenameStmt::relation_type() const {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.relation_type)
  return _internal_relation_type();
}
inline void RenameStmt::_internal_set_relation_type(::pg_query::ObjectType value) {
  
  relation_type_ = value;
}
inline void RenameStmt::set_relation_type(::pg_query::ObjectType value) {
  _internal_set_relation_type(value);
  // @@protoc_insertion_point(field_set:pg_query.RenameStmt.relation_type)
}

// .pg_query.RangeVar relation = 3 [json_name = "relation"];
inline bool RenameStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool RenameStmt::has_relation() const {
  return _internal_has_relation();
}
inline void RenameStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& RenameStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& RenameStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.relation)
  return _internal_relation();
}
inline void RenameStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RenameStmt.relation)
}
inline ::pg_query::RangeVar* RenameStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* RenameStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.RenameStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* RenameStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* RenameStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.RenameStmt.relation)
  return _internal_mutable_relation();
}
inline void RenameStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RenameStmt.relation)
}

// .pg_query.Node object = 4 [json_name = "object"];
inline bool RenameStmt::_internal_has_object() const {
  return this != internal_default_instance() && object_ != nullptr;
}
inline bool RenameStmt::has_object() const {
  return _internal_has_object();
}
inline void RenameStmt::clear_object() {
  if (GetArena() == nullptr && object_ != nullptr) {
    delete object_;
  }
  object_ = nullptr;
}
inline const ::pg_query::Node& RenameStmt::_internal_object() const {
  const ::pg_query::Node* p = object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RenameStmt::object() const {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.object)
  return _internal_object();
}
inline void RenameStmt::unsafe_arena_set_allocated_object(
    ::pg_query::Node* object) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(object_);
  }
  object_ = object;
  if (object) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RenameStmt.object)
}
inline ::pg_query::Node* RenameStmt::release_object() {
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RenameStmt::unsafe_arena_release_object() {
  // @@protoc_insertion_point(field_release:pg_query.RenameStmt.object)
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RenameStmt::_internal_mutable_object() {
  
  if (object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    object_ = p;
  }
  return object_;
}
inline ::pg_query::Node* RenameStmt::mutable_object() {
  // @@protoc_insertion_point(field_mutable:pg_query.RenameStmt.object)
  return _internal_mutable_object();
}
inline void RenameStmt::set_allocated_object(::pg_query::Node* object) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete object_;
  }
  if (object) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(object);
    if (message_arena != submessage_arena) {
      object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, object, submessage_arena);
    }
    
  } else {
    
  }
  object_ = object;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RenameStmt.object)
}

// string subname = 5 [json_name = "subname"];
inline void RenameStmt::clear_subname() {
  subname_.ClearToEmpty();
}
inline const std::string& RenameStmt::subname() const {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.subname)
  return _internal_subname();
}
inline void RenameStmt::set_subname(const std::string& value) {
  _internal_set_subname(value);
  // @@protoc_insertion_point(field_set:pg_query.RenameStmt.subname)
}
inline std::string* RenameStmt::mutable_subname() {
  // @@protoc_insertion_point(field_mutable:pg_query.RenameStmt.subname)
  return _internal_mutable_subname();
}
inline const std::string& RenameStmt::_internal_subname() const {
  return subname_.Get();
}
inline void RenameStmt::_internal_set_subname(const std::string& value) {
  
  subname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RenameStmt::set_subname(std::string&& value) {
  
  subname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.RenameStmt.subname)
}
inline void RenameStmt::set_subname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  subname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.RenameStmt.subname)
}
inline void RenameStmt::set_subname(const char* value,
    size_t size) {
  
  subname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.RenameStmt.subname)
}
inline std::string* RenameStmt::_internal_mutable_subname() {
  
  return subname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RenameStmt::release_subname() {
  // @@protoc_insertion_point(field_release:pg_query.RenameStmt.subname)
  return subname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RenameStmt::set_allocated_subname(std::string* subname) {
  if (subname != nullptr) {
    
  } else {
    
  }
  subname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), subname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.RenameStmt.subname)
}

// string newname = 6 [json_name = "newname"];
inline void RenameStmt::clear_newname() {
  newname_.ClearToEmpty();
}
inline const std::string& RenameStmt::newname() const {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.newname)
  return _internal_newname();
}
inline void RenameStmt::set_newname(const std::string& value) {
  _internal_set_newname(value);
  // @@protoc_insertion_point(field_set:pg_query.RenameStmt.newname)
}
inline std::string* RenameStmt::mutable_newname() {
  // @@protoc_insertion_point(field_mutable:pg_query.RenameStmt.newname)
  return _internal_mutable_newname();
}
inline const std::string& RenameStmt::_internal_newname() const {
  return newname_.Get();
}
inline void RenameStmt::_internal_set_newname(const std::string& value) {
  
  newname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RenameStmt::set_newname(std::string&& value) {
  
  newname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.RenameStmt.newname)
}
inline void RenameStmt::set_newname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  newname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.RenameStmt.newname)
}
inline void RenameStmt::set_newname(const char* value,
    size_t size) {
  
  newname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.RenameStmt.newname)
}
inline std::string* RenameStmt::_internal_mutable_newname() {
  
  return newname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RenameStmt::release_newname() {
  // @@protoc_insertion_point(field_release:pg_query.RenameStmt.newname)
  return newname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RenameStmt::set_allocated_newname(std::string* newname) {
  if (newname != nullptr) {
    
  } else {
    
  }
  newname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), newname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.RenameStmt.newname)
}

// .pg_query.DropBehavior behavior = 7 [json_name = "behavior"];
inline void RenameStmt::clear_behavior() {
  behavior_ = 0;
}
inline ::pg_query::DropBehavior RenameStmt::_internal_behavior() const {
  return static_cast< ::pg_query::DropBehavior >(behavior_);
}
inline ::pg_query::DropBehavior RenameStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.behavior)
  return _internal_behavior();
}
inline void RenameStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  
  behavior_ = value;
}
inline void RenameStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.RenameStmt.behavior)
}

// bool missing_ok = 8 [json_name = "missing_ok"];
inline void RenameStmt::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool RenameStmt::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool RenameStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.missing_ok)
  return _internal_missing_ok();
}
inline void RenameStmt::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void RenameStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.RenameStmt.missing_ok)
}

// -------------------------------------------------------------------

// RuleStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool RuleStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool RuleStmt::has_relation() const {
  return _internal_has_relation();
}
inline void RuleStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& RuleStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& RuleStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.RuleStmt.relation)
  return _internal_relation();
}
inline void RuleStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RuleStmt.relation)
}
inline ::pg_query::RangeVar* RuleStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* RuleStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.RuleStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* RuleStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* RuleStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.RuleStmt.relation)
  return _internal_mutable_relation();
}
inline void RuleStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RuleStmt.relation)
}

// string rulename = 2 [json_name = "rulename"];
inline void RuleStmt::clear_rulename() {
  rulename_.ClearToEmpty();
}
inline const std::string& RuleStmt::rulename() const {
  // @@protoc_insertion_point(field_get:pg_query.RuleStmt.rulename)
  return _internal_rulename();
}
inline void RuleStmt::set_rulename(const std::string& value) {
  _internal_set_rulename(value);
  // @@protoc_insertion_point(field_set:pg_query.RuleStmt.rulename)
}
inline std::string* RuleStmt::mutable_rulename() {
  // @@protoc_insertion_point(field_mutable:pg_query.RuleStmt.rulename)
  return _internal_mutable_rulename();
}
inline const std::string& RuleStmt::_internal_rulename() const {
  return rulename_.Get();
}
inline void RuleStmt::_internal_set_rulename(const std::string& value) {
  
  rulename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RuleStmt::set_rulename(std::string&& value) {
  
  rulename_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.RuleStmt.rulename)
}
inline void RuleStmt::set_rulename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  rulename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.RuleStmt.rulename)
}
inline void RuleStmt::set_rulename(const char* value,
    size_t size) {
  
  rulename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.RuleStmt.rulename)
}
inline std::string* RuleStmt::_internal_mutable_rulename() {
  
  return rulename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RuleStmt::release_rulename() {
  // @@protoc_insertion_point(field_release:pg_query.RuleStmt.rulename)
  return rulename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RuleStmt::set_allocated_rulename(std::string* rulename) {
  if (rulename != nullptr) {
    
  } else {
    
  }
  rulename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), rulename,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.RuleStmt.rulename)
}

// .pg_query.Node where_clause = 3 [json_name = "whereClause"];
inline bool RuleStmt::_internal_has_where_clause() const {
  return this != internal_default_instance() && where_clause_ != nullptr;
}
inline bool RuleStmt::has_where_clause() const {
  return _internal_has_where_clause();
}
inline void RuleStmt::clear_where_clause() {
  if (GetArena() == nullptr && where_clause_ != nullptr) {
    delete where_clause_;
  }
  where_clause_ = nullptr;
}
inline const ::pg_query::Node& RuleStmt::_internal_where_clause() const {
  const ::pg_query::Node* p = where_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RuleStmt::where_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.RuleStmt.where_clause)
  return _internal_where_clause();
}
inline void RuleStmt::unsafe_arena_set_allocated_where_clause(
    ::pg_query::Node* where_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(where_clause_);
  }
  where_clause_ = where_clause;
  if (where_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RuleStmt.where_clause)
}
inline ::pg_query::Node* RuleStmt::release_where_clause() {
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RuleStmt::unsafe_arena_release_where_clause() {
  // @@protoc_insertion_point(field_release:pg_query.RuleStmt.where_clause)
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RuleStmt::_internal_mutable_where_clause() {
  
  if (where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    where_clause_ = p;
  }
  return where_clause_;
}
inline ::pg_query::Node* RuleStmt::mutable_where_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.RuleStmt.where_clause)
  return _internal_mutable_where_clause();
}
inline void RuleStmt::set_allocated_where_clause(::pg_query::Node* where_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete where_clause_;
  }
  if (where_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(where_clause);
    if (message_arena != submessage_arena) {
      where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, where_clause, submessage_arena);
    }
    
  } else {
    
  }
  where_clause_ = where_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RuleStmt.where_clause)
}

// .pg_query.CmdType event = 4 [json_name = "event"];
inline void RuleStmt::clear_event() {
  event_ = 0;
}
inline ::pg_query::CmdType RuleStmt::_internal_event() const {
  return static_cast< ::pg_query::CmdType >(event_);
}
inline ::pg_query::CmdType RuleStmt::event() const {
  // @@protoc_insertion_point(field_get:pg_query.RuleStmt.event)
  return _internal_event();
}
inline void RuleStmt::_internal_set_event(::pg_query::CmdType value) {
  
  event_ = value;
}
inline void RuleStmt::set_event(::pg_query::CmdType value) {
  _internal_set_event(value);
  // @@protoc_insertion_point(field_set:pg_query.RuleStmt.event)
}

// bool instead = 5 [json_name = "instead"];
inline void RuleStmt::clear_instead() {
  instead_ = false;
}
inline bool RuleStmt::_internal_instead() const {
  return instead_;
}
inline bool RuleStmt::instead() const {
  // @@protoc_insertion_point(field_get:pg_query.RuleStmt.instead)
  return _internal_instead();
}
inline void RuleStmt::_internal_set_instead(bool value) {
  
  instead_ = value;
}
inline void RuleStmt::set_instead(bool value) {
  _internal_set_instead(value);
  // @@protoc_insertion_point(field_set:pg_query.RuleStmt.instead)
}

// repeated .pg_query.Node actions = 6 [json_name = "actions"];
inline int RuleStmt::_internal_actions_size() const {
  return actions_.size();
}
inline int RuleStmt::actions_size() const {
  return _internal_actions_size();
}
inline void RuleStmt::clear_actions() {
  actions_.Clear();
}
inline ::pg_query::Node* RuleStmt::mutable_actions(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RuleStmt.actions)
  return actions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RuleStmt::mutable_actions() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RuleStmt.actions)
  return &actions_;
}
inline const ::pg_query::Node& RuleStmt::_internal_actions(int index) const {
  return actions_.Get(index);
}
inline const ::pg_query::Node& RuleStmt::actions(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RuleStmt.actions)
  return _internal_actions(index);
}
inline ::pg_query::Node* RuleStmt::_internal_add_actions() {
  return actions_.Add();
}
inline ::pg_query::Node* RuleStmt::add_actions() {
  // @@protoc_insertion_point(field_add:pg_query.RuleStmt.actions)
  return _internal_add_actions();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RuleStmt::actions() const {
  // @@protoc_insertion_point(field_list:pg_query.RuleStmt.actions)
  return actions_;
}

// bool replace = 7 [json_name = "replace"];
inline void RuleStmt::clear_replace() {
  replace_ = false;
}
inline bool RuleStmt::_internal_replace() const {
  return replace_;
}
inline bool RuleStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.RuleStmt.replace)
  return _internal_replace();
}
inline void RuleStmt::_internal_set_replace(bool value) {
  
  replace_ = value;
}
inline void RuleStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.RuleStmt.replace)
}

// -------------------------------------------------------------------

// NotifyStmt

// string conditionname = 1 [json_name = "conditionname"];
inline void NotifyStmt::clear_conditionname() {
  conditionname_.ClearToEmpty();
}
inline const std::string& NotifyStmt::conditionname() const {
  // @@protoc_insertion_point(field_get:pg_query.NotifyStmt.conditionname)
  return _internal_conditionname();
}
inline void NotifyStmt::set_conditionname(const std::string& value) {
  _internal_set_conditionname(value);
  // @@protoc_insertion_point(field_set:pg_query.NotifyStmt.conditionname)
}
inline std::string* NotifyStmt::mutable_conditionname() {
  // @@protoc_insertion_point(field_mutable:pg_query.NotifyStmt.conditionname)
  return _internal_mutable_conditionname();
}
inline const std::string& NotifyStmt::_internal_conditionname() const {
  return conditionname_.Get();
}
inline void NotifyStmt::_internal_set_conditionname(const std::string& value) {
  
  conditionname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void NotifyStmt::set_conditionname(std::string&& value) {
  
  conditionname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.NotifyStmt.conditionname)
}
inline void NotifyStmt::set_conditionname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  conditionname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.NotifyStmt.conditionname)
}
inline void NotifyStmt::set_conditionname(const char* value,
    size_t size) {
  
  conditionname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.NotifyStmt.conditionname)
}
inline std::string* NotifyStmt::_internal_mutable_conditionname() {
  
  return conditionname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* NotifyStmt::release_conditionname() {
  // @@protoc_insertion_point(field_release:pg_query.NotifyStmt.conditionname)
  return conditionname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void NotifyStmt::set_allocated_conditionname(std::string* conditionname) {
  if (conditionname != nullptr) {
    
  } else {
    
  }
  conditionname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), conditionname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.NotifyStmt.conditionname)
}

// string payload = 2 [json_name = "payload"];
inline void NotifyStmt::clear_payload() {
  payload_.ClearToEmpty();
}
inline const std::string& NotifyStmt::payload() const {
  // @@protoc_insertion_point(field_get:pg_query.NotifyStmt.payload)
  return _internal_payload();
}
inline void NotifyStmt::set_payload(const std::string& value) {
  _internal_set_payload(value);
  // @@protoc_insertion_point(field_set:pg_query.NotifyStmt.payload)
}
inline std::string* NotifyStmt::mutable_payload() {
  // @@protoc_insertion_point(field_mutable:pg_query.NotifyStmt.payload)
  return _internal_mutable_payload();
}
inline const std::string& NotifyStmt::_internal_payload() const {
  return payload_.Get();
}
inline void NotifyStmt::_internal_set_payload(const std::string& value) {
  
  payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void NotifyStmt::set_payload(std::string&& value) {
  
  payload_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.NotifyStmt.payload)
}
inline void NotifyStmt::set_payload(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.NotifyStmt.payload)
}
inline void NotifyStmt::set_payload(const char* value,
    size_t size) {
  
  payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.NotifyStmt.payload)
}
inline std::string* NotifyStmt::_internal_mutable_payload() {
  
  return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* NotifyStmt::release_payload() {
  // @@protoc_insertion_point(field_release:pg_query.NotifyStmt.payload)
  return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void NotifyStmt::set_allocated_payload(std::string* payload) {
  if (payload != nullptr) {
    
  } else {
    
  }
  payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.NotifyStmt.payload)
}

// -------------------------------------------------------------------

// ListenStmt

// string conditionname = 1 [json_name = "conditionname"];
inline void ListenStmt::clear_conditionname() {
  conditionname_.ClearToEmpty();
}
inline const std::string& ListenStmt::conditionname() const {
  // @@protoc_insertion_point(field_get:pg_query.ListenStmt.conditionname)
  return _internal_conditionname();
}
inline void ListenStmt::set_conditionname(const std::string& value) {
  _internal_set_conditionname(value);
  // @@protoc_insertion_point(field_set:pg_query.ListenStmt.conditionname)
}
inline std::string* ListenStmt::mutable_conditionname() {
  // @@protoc_insertion_point(field_mutable:pg_query.ListenStmt.conditionname)
  return _internal_mutable_conditionname();
}
inline const std::string& ListenStmt::_internal_conditionname() const {
  return conditionname_.Get();
}
inline void ListenStmt::_internal_set_conditionname(const std::string& value) {
  
  conditionname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ListenStmt::set_conditionname(std::string&& value) {
  
  conditionname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ListenStmt.conditionname)
}
inline void ListenStmt::set_conditionname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  conditionname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ListenStmt.conditionname)
}
inline void ListenStmt::set_conditionname(const char* value,
    size_t size) {
  
  conditionname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ListenStmt.conditionname)
}
inline std::string* ListenStmt::_internal_mutable_conditionname() {
  
  return conditionname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ListenStmt::release_conditionname() {
  // @@protoc_insertion_point(field_release:pg_query.ListenStmt.conditionname)
  return conditionname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ListenStmt::set_allocated_conditionname(std::string* conditionname) {
  if (conditionname != nullptr) {
    
  } else {
    
  }
  conditionname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), conditionname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ListenStmt.conditionname)
}

// -------------------------------------------------------------------

// UnlistenStmt

// string conditionname = 1 [json_name = "conditionname"];
inline void UnlistenStmt::clear_conditionname() {
  conditionname_.ClearToEmpty();
}
inline const std::string& UnlistenStmt::conditionname() const {
  // @@protoc_insertion_point(field_get:pg_query.UnlistenStmt.conditionname)
  return _internal_conditionname();
}
inline void UnlistenStmt::set_conditionname(const std::string& value) {
  _internal_set_conditionname(value);
  // @@protoc_insertion_point(field_set:pg_query.UnlistenStmt.conditionname)
}
inline std::string* UnlistenStmt::mutable_conditionname() {
  // @@protoc_insertion_point(field_mutable:pg_query.UnlistenStmt.conditionname)
  return _internal_mutable_conditionname();
}
inline const std::string& UnlistenStmt::_internal_conditionname() const {
  return conditionname_.Get();
}
inline void UnlistenStmt::_internal_set_conditionname(const std::string& value) {
  
  conditionname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void UnlistenStmt::set_conditionname(std::string&& value) {
  
  conditionname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.UnlistenStmt.conditionname)
}
inline void UnlistenStmt::set_conditionname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  conditionname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.UnlistenStmt.conditionname)
}
inline void UnlistenStmt::set_conditionname(const char* value,
    size_t size) {
  
  conditionname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.UnlistenStmt.conditionname)
}
inline std::string* UnlistenStmt::_internal_mutable_conditionname() {
  
  return conditionname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* UnlistenStmt::release_conditionname() {
  // @@protoc_insertion_point(field_release:pg_query.UnlistenStmt.conditionname)
  return conditionname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void UnlistenStmt::set_allocated_conditionname(std::string* conditionname) {
  if (conditionname != nullptr) {
    
  } else {
    
  }
  conditionname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), conditionname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.UnlistenStmt.conditionname)
}

// -------------------------------------------------------------------

// TransactionStmt

// .pg_query.TransactionStmtKind kind = 1 [json_name = "kind"];
inline void TransactionStmt::clear_kind() {
  kind_ = 0;
}
inline ::pg_query::TransactionStmtKind TransactionStmt::_internal_kind() const {
  return static_cast< ::pg_query::TransactionStmtKind >(kind_);
}
inline ::pg_query::TransactionStmtKind TransactionStmt::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.kind)
  return _internal_kind();
}
inline void TransactionStmt::_internal_set_kind(::pg_query::TransactionStmtKind value) {
  
  kind_ = value;
}
inline void TransactionStmt::set_kind(::pg_query::TransactionStmtKind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.TransactionStmt.kind)
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int TransactionStmt::_internal_options_size() const {
  return options_.size();
}
inline int TransactionStmt::options_size() const {
  return _internal_options_size();
}
inline void TransactionStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* TransactionStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TransactionStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TransactionStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TransactionStmt.options)
  return &options_;
}
inline const ::pg_query::Node& TransactionStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& TransactionStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* TransactionStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* TransactionStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.TransactionStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TransactionStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.TransactionStmt.options)
  return options_;
}

// string savepoint_name = 3 [json_name = "savepoint_name"];
inline void TransactionStmt::clear_savepoint_name() {
  savepoint_name_.ClearToEmpty();
}
inline const std::string& TransactionStmt::savepoint_name() const {
  // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.savepoint_name)
  return _internal_savepoint_name();
}
inline void TransactionStmt::set_savepoint_name(const std::string& value) {
  _internal_set_savepoint_name(value);
  // @@protoc_insertion_point(field_set:pg_query.TransactionStmt.savepoint_name)
}
inline std::string* TransactionStmt::mutable_savepoint_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.TransactionStmt.savepoint_name)
  return _internal_mutable_savepoint_name();
}
inline const std::string& TransactionStmt::_internal_savepoint_name() const {
  return savepoint_name_.Get();
}
inline void TransactionStmt::_internal_set_savepoint_name(const std::string& value) {
  
  savepoint_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void TransactionStmt::set_savepoint_name(std::string&& value) {
  
  savepoint_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.TransactionStmt.savepoint_name)
}
inline void TransactionStmt::set_savepoint_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  savepoint_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.TransactionStmt.savepoint_name)
}
inline void TransactionStmt::set_savepoint_name(const char* value,
    size_t size) {
  
  savepoint_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.TransactionStmt.savepoint_name)
}
inline std::string* TransactionStmt::_internal_mutable_savepoint_name() {
  
  return savepoint_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* TransactionStmt::release_savepoint_name() {
  // @@protoc_insertion_point(field_release:pg_query.TransactionStmt.savepoint_name)
  return savepoint_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void TransactionStmt::set_allocated_savepoint_name(std::string* savepoint_name) {
  if (savepoint_name != nullptr) {
    
  } else {
    
  }
  savepoint_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), savepoint_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.TransactionStmt.savepoint_name)
}

// string gid = 4 [json_name = "gid"];
inline void TransactionStmt::clear_gid() {
  gid_.ClearToEmpty();
}
inline const std::string& TransactionStmt::gid() const {
  // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.gid)
  return _internal_gid();
}
inline void TransactionStmt::set_gid(const std::string& value) {
  _internal_set_gid(value);
  // @@protoc_insertion_point(field_set:pg_query.TransactionStmt.gid)
}
inline std::string* TransactionStmt::mutable_gid() {
  // @@protoc_insertion_point(field_mutable:pg_query.TransactionStmt.gid)
  return _internal_mutable_gid();
}
inline const std::string& TransactionStmt::_internal_gid() const {
  return gid_.Get();
}
inline void TransactionStmt::_internal_set_gid(const std::string& value) {
  
  gid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void TransactionStmt::set_gid(std::string&& value) {
  
  gid_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.TransactionStmt.gid)
}
inline void TransactionStmt::set_gid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  gid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.TransactionStmt.gid)
}
inline void TransactionStmt::set_gid(const char* value,
    size_t size) {
  
  gid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.TransactionStmt.gid)
}
inline std::string* TransactionStmt::_internal_mutable_gid() {
  
  return gid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* TransactionStmt::release_gid() {
  // @@protoc_insertion_point(field_release:pg_query.TransactionStmt.gid)
  return gid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void TransactionStmt::set_allocated_gid(std::string* gid) {
  if (gid != nullptr) {
    
  } else {
    
  }
  gid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), gid,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.TransactionStmt.gid)
}

// bool chain = 5 [json_name = "chain"];
inline void TransactionStmt::clear_chain() {
  chain_ = false;
}
inline bool TransactionStmt::_internal_chain() const {
  return chain_;
}
inline bool TransactionStmt::chain() const {
  // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.chain)
  return _internal_chain();
}
inline void TransactionStmt::_internal_set_chain(bool value) {
  
  chain_ = value;
}
inline void TransactionStmt::set_chain(bool value) {
  _internal_set_chain(value);
  // @@protoc_insertion_point(field_set:pg_query.TransactionStmt.chain)
}

// -------------------------------------------------------------------

// ViewStmt

// .pg_query.RangeVar view = 1 [json_name = "view"];
inline bool ViewStmt::_internal_has_view() const {
  return this != internal_default_instance() && view_ != nullptr;
}
inline bool ViewStmt::has_view() const {
  return _internal_has_view();
}
inline void ViewStmt::clear_view() {
  if (GetArena() == nullptr && view_ != nullptr) {
    delete view_;
  }
  view_ = nullptr;
}
inline const ::pg_query::RangeVar& ViewStmt::_internal_view() const {
  const ::pg_query::RangeVar* p = view_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& ViewStmt::view() const {
  // @@protoc_insertion_point(field_get:pg_query.ViewStmt.view)
  return _internal_view();
}
inline void ViewStmt::unsafe_arena_set_allocated_view(
    ::pg_query::RangeVar* view) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(view_);
  }
  view_ = view;
  if (view) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ViewStmt.view)
}
inline ::pg_query::RangeVar* ViewStmt::release_view() {
  
  ::pg_query::RangeVar* temp = view_;
  view_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* ViewStmt::unsafe_arena_release_view() {
  // @@protoc_insertion_point(field_release:pg_query.ViewStmt.view)
  
  ::pg_query::RangeVar* temp = view_;
  view_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* ViewStmt::_internal_mutable_view() {
  
  if (view_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    view_ = p;
  }
  return view_;
}
inline ::pg_query::RangeVar* ViewStmt::mutable_view() {
  // @@protoc_insertion_point(field_mutable:pg_query.ViewStmt.view)
  return _internal_mutable_view();
}
inline void ViewStmt::set_allocated_view(::pg_query::RangeVar* view) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete view_;
  }
  if (view) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(view);
    if (message_arena != submessage_arena) {
      view = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, view, submessage_arena);
    }
    
  } else {
    
  }
  view_ = view;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ViewStmt.view)
}

// repeated .pg_query.Node aliases = 2 [json_name = "aliases"];
inline int ViewStmt::_internal_aliases_size() const {
  return aliases_.size();
}
inline int ViewStmt::aliases_size() const {
  return _internal_aliases_size();
}
inline void ViewStmt::clear_aliases() {
  aliases_.Clear();
}
inline ::pg_query::Node* ViewStmt::mutable_aliases(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ViewStmt.aliases)
  return aliases_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ViewStmt::mutable_aliases() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ViewStmt.aliases)
  return &aliases_;
}
inline const ::pg_query::Node& ViewStmt::_internal_aliases(int index) const {
  return aliases_.Get(index);
}
inline const ::pg_query::Node& ViewStmt::aliases(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ViewStmt.aliases)
  return _internal_aliases(index);
}
inline ::pg_query::Node* ViewStmt::_internal_add_aliases() {
  return aliases_.Add();
}
inline ::pg_query::Node* ViewStmt::add_aliases() {
  // @@protoc_insertion_point(field_add:pg_query.ViewStmt.aliases)
  return _internal_add_aliases();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ViewStmt::aliases() const {
  // @@protoc_insertion_point(field_list:pg_query.ViewStmt.aliases)
  return aliases_;
}

// .pg_query.Node query = 3 [json_name = "query"];
inline bool ViewStmt::_internal_has_query() const {
  return this != internal_default_instance() && query_ != nullptr;
}
inline bool ViewStmt::has_query() const {
  return _internal_has_query();
}
inline void ViewStmt::clear_query() {
  if (GetArena() == nullptr && query_ != nullptr) {
    delete query_;
  }
  query_ = nullptr;
}
inline const ::pg_query::Node& ViewStmt::_internal_query() const {
  const ::pg_query::Node* p = query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ViewStmt::query() const {
  // @@protoc_insertion_point(field_get:pg_query.ViewStmt.query)
  return _internal_query();
}
inline void ViewStmt::unsafe_arena_set_allocated_query(
    ::pg_query::Node* query) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(query_);
  }
  query_ = query;
  if (query) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ViewStmt.query)
}
inline ::pg_query::Node* ViewStmt::release_query() {
  
  ::pg_query::Node* temp = query_;
  query_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* ViewStmt::unsafe_arena_release_query() {
  // @@protoc_insertion_point(field_release:pg_query.ViewStmt.query)
  
  ::pg_query::Node* temp = query_;
  query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ViewStmt::_internal_mutable_query() {
  
  if (query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    query_ = p;
  }
  return query_;
}
inline ::pg_query::Node* ViewStmt::mutable_query() {
  // @@protoc_insertion_point(field_mutable:pg_query.ViewStmt.query)
  return _internal_mutable_query();
}
inline void ViewStmt::set_allocated_query(::pg_query::Node* query) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete query_;
  }
  if (query) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(query);
    if (message_arena != submessage_arena) {
      query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, query, submessage_arena);
    }
    
  } else {
    
  }
  query_ = query;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ViewStmt.query)
}

// bool replace = 4 [json_name = "replace"];
inline void ViewStmt::clear_replace() {
  replace_ = false;
}
inline bool ViewStmt::_internal_replace() const {
  return replace_;
}
inline bool ViewStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.ViewStmt.replace)
  return _internal_replace();
}
inline void ViewStmt::_internal_set_replace(bool value) {
  
  replace_ = value;
}
inline void ViewStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.ViewStmt.replace)
}

// repeated .pg_query.Node options = 5 [json_name = "options"];
inline int ViewStmt::_internal_options_size() const {
  return options_.size();
}
inline int ViewStmt::options_size() const {
  return _internal_options_size();
}
inline void ViewStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* ViewStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ViewStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ViewStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ViewStmt.options)
  return &options_;
}
inline const ::pg_query::Node& ViewStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& ViewStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ViewStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* ViewStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* ViewStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.ViewStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ViewStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.ViewStmt.options)
  return options_;
}

// .pg_query.ViewCheckOption with_check_option = 6 [json_name = "withCheckOption"];
inline void ViewStmt::clear_with_check_option() {
  with_check_option_ = 0;
}
inline ::pg_query::ViewCheckOption ViewStmt::_internal_with_check_option() const {
  return static_cast< ::pg_query::ViewCheckOption >(with_check_option_);
}
inline ::pg_query::ViewCheckOption ViewStmt::with_check_option() const {
  // @@protoc_insertion_point(field_get:pg_query.ViewStmt.with_check_option)
  return _internal_with_check_option();
}
inline void ViewStmt::_internal_set_with_check_option(::pg_query::ViewCheckOption value) {
  
  with_check_option_ = value;
}
inline void ViewStmt::set_with_check_option(::pg_query::ViewCheckOption value) {
  _internal_set_with_check_option(value);
  // @@protoc_insertion_point(field_set:pg_query.ViewStmt.with_check_option)
}

// -------------------------------------------------------------------

// LoadStmt

// string filename = 1 [json_name = "filename"];
inline void LoadStmt::clear_filename() {
  filename_.ClearToEmpty();
}
inline const std::string& LoadStmt::filename() const {
  // @@protoc_insertion_point(field_get:pg_query.LoadStmt.filename)
  return _internal_filename();
}
inline void LoadStmt::set_filename(const std::string& value) {
  _internal_set_filename(value);
  // @@protoc_insertion_point(field_set:pg_query.LoadStmt.filename)
}
inline std::string* LoadStmt::mutable_filename() {
  // @@protoc_insertion_point(field_mutable:pg_query.LoadStmt.filename)
  return _internal_mutable_filename();
}
inline const std::string& LoadStmt::_internal_filename() const {
  return filename_.Get();
}
inline void LoadStmt::_internal_set_filename(const std::string& value) {
  
  filename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void LoadStmt::set_filename(std::string&& value) {
  
  filename_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.LoadStmt.filename)
}
inline void LoadStmt::set_filename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  filename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.LoadStmt.filename)
}
inline void LoadStmt::set_filename(const char* value,
    size_t size) {
  
  filename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.LoadStmt.filename)
}
inline std::string* LoadStmt::_internal_mutable_filename() {
  
  return filename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* LoadStmt::release_filename() {
  // @@protoc_insertion_point(field_release:pg_query.LoadStmt.filename)
  return filename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void LoadStmt::set_allocated_filename(std::string* filename) {
  if (filename != nullptr) {
    
  } else {
    
  }
  filename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), filename,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.LoadStmt.filename)
}

// -------------------------------------------------------------------

// CreateDomainStmt

// repeated .pg_query.Node domainname = 1 [json_name = "domainname"];
inline int CreateDomainStmt::_internal_domainname_size() const {
  return domainname_.size();
}
inline int CreateDomainStmt::domainname_size() const {
  return _internal_domainname_size();
}
inline void CreateDomainStmt::clear_domainname() {
  domainname_.Clear();
}
inline ::pg_query::Node* CreateDomainStmt::mutable_domainname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateDomainStmt.domainname)
  return domainname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateDomainStmt::mutable_domainname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateDomainStmt.domainname)
  return &domainname_;
}
inline const ::pg_query::Node& CreateDomainStmt::_internal_domainname(int index) const {
  return domainname_.Get(index);
}
inline const ::pg_query::Node& CreateDomainStmt::domainname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateDomainStmt.domainname)
  return _internal_domainname(index);
}
inline ::pg_query::Node* CreateDomainStmt::_internal_add_domainname() {
  return domainname_.Add();
}
inline ::pg_query::Node* CreateDomainStmt::add_domainname() {
  // @@protoc_insertion_point(field_add:pg_query.CreateDomainStmt.domainname)
  return _internal_add_domainname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateDomainStmt::domainname() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateDomainStmt.domainname)
  return domainname_;
}

// .pg_query.TypeName type_name = 2 [json_name = "typeName"];
inline bool CreateDomainStmt::_internal_has_type_name() const {
  return this != internal_default_instance() && type_name_ != nullptr;
}
inline bool CreateDomainStmt::has_type_name() const {
  return _internal_has_type_name();
}
inline void CreateDomainStmt::clear_type_name() {
  if (GetArena() == nullptr && type_name_ != nullptr) {
    delete type_name_;
  }
  type_name_ = nullptr;
}
inline const ::pg_query::TypeName& CreateDomainStmt::_internal_type_name() const {
  const ::pg_query::TypeName* p = type_name_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(
      ::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& CreateDomainStmt::type_name() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateDomainStmt.type_name)
  return _internal_type_name();
}
inline void CreateDomainStmt::unsafe_arena_set_allocated_type_name(
    ::pg_query::TypeName* type_name) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_name_);
  }
  type_name_ = type_name;
  if (type_name) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateDomainStmt.type_name)
}
inline ::pg_query::TypeName* CreateDomainStmt::release_type_name() {
  
  ::pg_query::TypeName* temp = type_name_;
  type_name_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TypeName* CreateDomainStmt::unsafe_arena_release_type_name() {
  // @@protoc_insertion_point(field_release:pg_query.CreateDomainStmt.type_name)
  
  ::pg_query::TypeName* temp = type_name_;
  type_name_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateDomainStmt::_internal_mutable_type_name() {
  
  if (type_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    type_name_ = p;
  }
  return type_name_;
}
inline ::pg_query::TypeName* CreateDomainStmt::mutable_type_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateDomainStmt.type_name)
  return _internal_mutable_type_name();
}
inline void CreateDomainStmt::set_allocated_type_name(::pg_query::TypeName* type_name) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete type_name_;
  }
  if (type_name) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_name);
    if (message_arena != submessage_arena) {
      type_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, type_name, submessage_arena);
    }
    
  } else {
    
  }
  type_name_ = type_name;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateDomainStmt.type_name)
}

// .pg_query.CollateClause coll_clause = 3 [json_name = "collClause"];
inline bool CreateDomainStmt::_internal_has_coll_clause() const {
  return this != internal_default_instance() && coll_clause_ != nullptr;
}
inline bool CreateDomainStmt::has_coll_clause() const {
  return _internal_has_coll_clause();
}
inline void CreateDomainStmt::clear_coll_clause() {
  if (GetArena() == nullptr && coll_clause_ != nullptr) {
    delete coll_clause_;
  }
  coll_clause_ = nullptr;
}
inline const ::pg_query::CollateClause& CreateDomainStmt::_internal_coll_clause() const {
  const ::pg_query::CollateClause* p = coll_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::CollateClause&>(
      ::pg_query::_CollateClause_default_instance_);
}
inline const ::pg_query::CollateClause& CreateDomainStmt::coll_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateDomainStmt.coll_clause)
  return _internal_coll_clause();
}
inline void CreateDomainStmt::unsafe_arena_set_allocated_coll_clause(
    ::pg_query::CollateClause* coll_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(coll_clause_);
  }
  coll_clause_ = coll_clause;
  if (coll_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateDomainStmt.coll_clause)
}
inline ::pg_query::CollateClause* CreateDomainStmt::release_coll_clause() {
  
  ::pg_query::CollateClause* temp = coll_clause_;
  coll_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::CollateClause* CreateDomainStmt::unsafe_arena_release_coll_clause() {
  // @@protoc_insertion_point(field_release:pg_query.CreateDomainStmt.coll_clause)
  
  ::pg_query::CollateClause* temp = coll_clause_;
  coll_clause_ = nullptr;
  return temp;
}
inline ::pg_query::CollateClause* CreateDomainStmt::_internal_mutable_coll_clause() {
  
  if (coll_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::CollateClause>(GetArena());
    coll_clause_ = p;
  }
  return coll_clause_;
}
inline ::pg_query::CollateClause* CreateDomainStmt::mutable_coll_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateDomainStmt.coll_clause)
  return _internal_mutable_coll_clause();
}
inline void CreateDomainStmt::set_allocated_coll_clause(::pg_query::CollateClause* coll_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete coll_clause_;
  }
  if (coll_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(coll_clause);
    if (message_arena != submessage_arena) {
      coll_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, coll_clause, submessage_arena);
    }
    
  } else {
    
  }
  coll_clause_ = coll_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateDomainStmt.coll_clause)
}

// repeated .pg_query.Node constraints = 4 [json_name = "constraints"];
inline int CreateDomainStmt::_internal_constraints_size() const {
  return constraints_.size();
}
inline int CreateDomainStmt::constraints_size() const {
  return _internal_constraints_size();
}
inline void CreateDomainStmt::clear_constraints() {
  constraints_.Clear();
}
inline ::pg_query::Node* CreateDomainStmt::mutable_constraints(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateDomainStmt.constraints)
  return constraints_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateDomainStmt::mutable_constraints() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateDomainStmt.constraints)
  return &constraints_;
}
inline const ::pg_query::Node& CreateDomainStmt::_internal_constraints(int index) const {
  return constraints_.Get(index);
}
inline const ::pg_query::Node& CreateDomainStmt::constraints(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateDomainStmt.constraints)
  return _internal_constraints(index);
}
inline ::pg_query::Node* CreateDomainStmt::_internal_add_constraints() {
  return constraints_.Add();
}
inline ::pg_query::Node* CreateDomainStmt::add_constraints() {
  // @@protoc_insertion_point(field_add:pg_query.CreateDomainStmt.constraints)
  return _internal_add_constraints();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateDomainStmt::constraints() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateDomainStmt.constraints)
  return constraints_;
}

// -------------------------------------------------------------------

// CreatedbStmt

// string dbname = 1 [json_name = "dbname"];
inline void CreatedbStmt::clear_dbname() {
  dbname_.ClearToEmpty();
}
inline const std::string& CreatedbStmt::dbname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatedbStmt.dbname)
  return _internal_dbname();
}
inline void CreatedbStmt::set_dbname(const std::string& value) {
  _internal_set_dbname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreatedbStmt.dbname)
}
inline std::string* CreatedbStmt::mutable_dbname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatedbStmt.dbname)
  return _internal_mutable_dbname();
}
inline const std::string& CreatedbStmt::_internal_dbname() const {
  return dbname_.Get();
}
inline void CreatedbStmt::_internal_set_dbname(const std::string& value) {
  
  dbname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreatedbStmt::set_dbname(std::string&& value) {
  
  dbname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreatedbStmt.dbname)
}
inline void CreatedbStmt::set_dbname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  dbname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreatedbStmt.dbname)
}
inline void CreatedbStmt::set_dbname(const char* value,
    size_t size) {
  
  dbname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreatedbStmt.dbname)
}
inline std::string* CreatedbStmt::_internal_mutable_dbname() {
  
  return dbname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreatedbStmt::release_dbname() {
  // @@protoc_insertion_point(field_release:pg_query.CreatedbStmt.dbname)
  return dbname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreatedbStmt::set_allocated_dbname(std::string* dbname) {
  if (dbname != nullptr) {
    
  } else {
    
  }
  dbname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dbname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreatedbStmt.dbname)
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int CreatedbStmt::_internal_options_size() const {
  return options_.size();
}
inline int CreatedbStmt::options_size() const {
  return _internal_options_size();
}
inline void CreatedbStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CreatedbStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatedbStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreatedbStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatedbStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CreatedbStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CreatedbStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreatedbStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CreatedbStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CreatedbStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreatedbStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreatedbStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreatedbStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// DropdbStmt

// string dbname = 1 [json_name = "dbname"];
inline void DropdbStmt::clear_dbname() {
  dbname_.ClearToEmpty();
}
inline const std::string& DropdbStmt::dbname() const {
  // @@protoc_insertion_point(field_get:pg_query.DropdbStmt.dbname)
  return _internal_dbname();
}
inline void DropdbStmt::set_dbname(const std::string& value) {
  _internal_set_dbname(value);
  // @@protoc_insertion_point(field_set:pg_query.DropdbStmt.dbname)
}
inline std::string* DropdbStmt::mutable_dbname() {
  // @@protoc_insertion_point(field_mutable:pg_query.DropdbStmt.dbname)
  return _internal_mutable_dbname();
}
inline const std::string& DropdbStmt::_internal_dbname() const {
  return dbname_.Get();
}
inline void DropdbStmt::_internal_set_dbname(const std::string& value) {
  
  dbname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void DropdbStmt::set_dbname(std::string&& value) {
  
  dbname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.DropdbStmt.dbname)
}
inline void DropdbStmt::set_dbname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  dbname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.DropdbStmt.dbname)
}
inline void DropdbStmt::set_dbname(const char* value,
    size_t size) {
  
  dbname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.DropdbStmt.dbname)
}
inline std::string* DropdbStmt::_internal_mutable_dbname() {
  
  return dbname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* DropdbStmt::release_dbname() {
  // @@protoc_insertion_point(field_release:pg_query.DropdbStmt.dbname)
  return dbname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void DropdbStmt::set_allocated_dbname(std::string* dbname) {
  if (dbname != nullptr) {
    
  } else {
    
  }
  dbname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dbname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.DropdbStmt.dbname)
}

// bool missing_ok = 2 [json_name = "missing_ok"];
inline void DropdbStmt::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool DropdbStmt::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool DropdbStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.DropdbStmt.missing_ok)
  return _internal_missing_ok();
}
inline void DropdbStmt::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void DropdbStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.DropdbStmt.missing_ok)
}

// repeated .pg_query.Node options = 3 [json_name = "options"];
inline int DropdbStmt::_internal_options_size() const {
  return options_.size();
}
inline int DropdbStmt::options_size() const {
  return _internal_options_size();
}
inline void DropdbStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* DropdbStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.DropdbStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
DropdbStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DropdbStmt.options)
  return &options_;
}
inline const ::pg_query::Node& DropdbStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& DropdbStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.DropdbStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* DropdbStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* DropdbStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.DropdbStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
DropdbStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.DropdbStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// VacuumStmt

// repeated .pg_query.Node options = 1 [json_name = "options"];
inline int VacuumStmt::_internal_options_size() const {
  return options_.size();
}
inline int VacuumStmt::options_size() const {
  return _internal_options_size();
}
inline void VacuumStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* VacuumStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.VacuumStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
VacuumStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.VacuumStmt.options)
  return &options_;
}
inline const ::pg_query::Node& VacuumStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& VacuumStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.VacuumStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* VacuumStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* VacuumStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.VacuumStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
VacuumStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.VacuumStmt.options)
  return options_;
}

// repeated .pg_query.Node rels = 2 [json_name = "rels"];
inline int VacuumStmt::_internal_rels_size() const {
  return rels_.size();
}
inline int VacuumStmt::rels_size() const {
  return _internal_rels_size();
}
inline void VacuumStmt::clear_rels() {
  rels_.Clear();
}
inline ::pg_query::Node* VacuumStmt::mutable_rels(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.VacuumStmt.rels)
  return rels_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
VacuumStmt::mutable_rels() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.VacuumStmt.rels)
  return &rels_;
}
inline const ::pg_query::Node& VacuumStmt::_internal_rels(int index) const {
  return rels_.Get(index);
}
inline const ::pg_query::Node& VacuumStmt::rels(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.VacuumStmt.rels)
  return _internal_rels(index);
}
inline ::pg_query::Node* VacuumStmt::_internal_add_rels() {
  return rels_.Add();
}
inline ::pg_query::Node* VacuumStmt::add_rels() {
  // @@protoc_insertion_point(field_add:pg_query.VacuumStmt.rels)
  return _internal_add_rels();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
VacuumStmt::rels() const {
  // @@protoc_insertion_point(field_list:pg_query.VacuumStmt.rels)
  return rels_;
}

// bool is_vacuumcmd = 3 [json_name = "is_vacuumcmd"];
inline void VacuumStmt::clear_is_vacuumcmd() {
  is_vacuumcmd_ = false;
}
inline bool VacuumStmt::_internal_is_vacuumcmd() const {
  return is_vacuumcmd_;
}
inline bool VacuumStmt::is_vacuumcmd() const {
  // @@protoc_insertion_point(field_get:pg_query.VacuumStmt.is_vacuumcmd)
  return _internal_is_vacuumcmd();
}
inline void VacuumStmt::_internal_set_is_vacuumcmd(bool value) {
  
  is_vacuumcmd_ = value;
}
inline void VacuumStmt::set_is_vacuumcmd(bool value) {
  _internal_set_is_vacuumcmd(value);
  // @@protoc_insertion_point(field_set:pg_query.VacuumStmt.is_vacuumcmd)
}

// -------------------------------------------------------------------

// ExplainStmt

// .pg_query.Node query = 1 [json_name = "query"];
inline bool ExplainStmt::_internal_has_query() const {
  return this != internal_default_instance() && query_ != nullptr;
}
inline bool ExplainStmt::has_query() const {
  return _internal_has_query();
}
inline void ExplainStmt::clear_query() {
  if (GetArena() == nullptr && query_ != nullptr) {
    delete query_;
  }
  query_ = nullptr;
}
inline const ::pg_query::Node& ExplainStmt::_internal_query() const {
  const ::pg_query::Node* p = query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ExplainStmt::query() const {
  // @@protoc_insertion_point(field_get:pg_query.ExplainStmt.query)
  return _internal_query();
}
inline void ExplainStmt::unsafe_arena_set_allocated_query(
    ::pg_query::Node* query) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(query_);
  }
  query_ = query;
  if (query) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ExplainStmt.query)
}
inline ::pg_query::Node* ExplainStmt::release_query() {
  
  ::pg_query::Node* temp = query_;
  query_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* ExplainStmt::unsafe_arena_release_query() {
  // @@protoc_insertion_point(field_release:pg_query.ExplainStmt.query)
  
  ::pg_query::Node* temp = query_;
  query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ExplainStmt::_internal_mutable_query() {
  
  if (query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    query_ = p;
  }
  return query_;
}
inline ::pg_query::Node* ExplainStmt::mutable_query() {
  // @@protoc_insertion_point(field_mutable:pg_query.ExplainStmt.query)
  return _internal_mutable_query();
}
inline void ExplainStmt::set_allocated_query(::pg_query::Node* query) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete query_;
  }
  if (query) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(query);
    if (message_arena != submessage_arena) {
      query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, query, submessage_arena);
    }
    
  } else {
    
  }
  query_ = query;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ExplainStmt.query)
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int ExplainStmt::_internal_options_size() const {
  return options_.size();
}
inline int ExplainStmt::options_size() const {
  return _internal_options_size();
}
inline void ExplainStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* ExplainStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ExplainStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ExplainStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ExplainStmt.options)
  return &options_;
}
inline const ::pg_query::Node& ExplainStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& ExplainStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ExplainStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* ExplainStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* ExplainStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.ExplainStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ExplainStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.ExplainStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// CreateTableAsStmt

// .pg_query.Node query = 1 [json_name = "query"];
inline bool CreateTableAsStmt::_internal_has_query() const {
  return this != internal_default_instance() && query_ != nullptr;
}
inline bool CreateTableAsStmt::has_query() const {
  return _internal_has_query();
}
inline void CreateTableAsStmt::clear_query() {
  if (GetArena() == nullptr && query_ != nullptr) {
    delete query_;
  }
  query_ = nullptr;
}
inline const ::pg_query::Node& CreateTableAsStmt::_internal_query() const {
  const ::pg_query::Node* p = query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CreateTableAsStmt::query() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableAsStmt.query)
  return _internal_query();
}
inline void CreateTableAsStmt::unsafe_arena_set_allocated_query(
    ::pg_query::Node* query) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(query_);
  }
  query_ = query;
  if (query) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTableAsStmt.query)
}
inline ::pg_query::Node* CreateTableAsStmt::release_query() {
  
  ::pg_query::Node* temp = query_;
  query_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CreateTableAsStmt::unsafe_arena_release_query() {
  // @@protoc_insertion_point(field_release:pg_query.CreateTableAsStmt.query)
  
  ::pg_query::Node* temp = query_;
  query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CreateTableAsStmt::_internal_mutable_query() {
  
  if (query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    query_ = p;
  }
  return query_;
}
inline ::pg_query::Node* CreateTableAsStmt::mutable_query() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTableAsStmt.query)
  return _internal_mutable_query();
}
inline void CreateTableAsStmt::set_allocated_query(::pg_query::Node* query) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete query_;
  }
  if (query) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(query);
    if (message_arena != submessage_arena) {
      query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, query, submessage_arena);
    }
    
  } else {
    
  }
  query_ = query;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTableAsStmt.query)
}

// .pg_query.IntoClause into = 2 [json_name = "into"];
inline bool CreateTableAsStmt::_internal_has_into() const {
  return this != internal_default_instance() && into_ != nullptr;
}
inline bool CreateTableAsStmt::has_into() const {
  return _internal_has_into();
}
inline void CreateTableAsStmt::clear_into() {
  if (GetArena() == nullptr && into_ != nullptr) {
    delete into_;
  }
  into_ = nullptr;
}
inline const ::pg_query::IntoClause& CreateTableAsStmt::_internal_into() const {
  const ::pg_query::IntoClause* p = into_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::IntoClause&>(
      ::pg_query::_IntoClause_default_instance_);
}
inline const ::pg_query::IntoClause& CreateTableAsStmt::into() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableAsStmt.into)
  return _internal_into();
}
inline void CreateTableAsStmt::unsafe_arena_set_allocated_into(
    ::pg_query::IntoClause* into) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(into_);
  }
  into_ = into;
  if (into) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTableAsStmt.into)
}
inline ::pg_query::IntoClause* CreateTableAsStmt::release_into() {
  
  ::pg_query::IntoClause* temp = into_;
  into_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::IntoClause* CreateTableAsStmt::unsafe_arena_release_into() {
  // @@protoc_insertion_point(field_release:pg_query.CreateTableAsStmt.into)
  
  ::pg_query::IntoClause* temp = into_;
  into_ = nullptr;
  return temp;
}
inline ::pg_query::IntoClause* CreateTableAsStmt::_internal_mutable_into() {
  
  if (into_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::IntoClause>(GetArena());
    into_ = p;
  }
  return into_;
}
inline ::pg_query::IntoClause* CreateTableAsStmt::mutable_into() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTableAsStmt.into)
  return _internal_mutable_into();
}
inline void CreateTableAsStmt::set_allocated_into(::pg_query::IntoClause* into) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete into_;
  }
  if (into) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(into);
    if (message_arena != submessage_arena) {
      into = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, into, submessage_arena);
    }
    
  } else {
    
  }
  into_ = into;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTableAsStmt.into)
}

// .pg_query.ObjectType relkind = 3 [json_name = "relkind"];
inline void CreateTableAsStmt::clear_relkind() {
  relkind_ = 0;
}
inline ::pg_query::ObjectType CreateTableAsStmt::_internal_relkind() const {
  return static_cast< ::pg_query::ObjectType >(relkind_);
}
inline ::pg_query::ObjectType CreateTableAsStmt::relkind() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableAsStmt.relkind)
  return _internal_relkind();
}
inline void CreateTableAsStmt::_internal_set_relkind(::pg_query::ObjectType value) {
  
  relkind_ = value;
}
inline void CreateTableAsStmt::set_relkind(::pg_query::ObjectType value) {
  _internal_set_relkind(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTableAsStmt.relkind)
}

// bool is_select_into = 4 [json_name = "is_select_into"];
inline void CreateTableAsStmt::clear_is_select_into() {
  is_select_into_ = false;
}
inline bool CreateTableAsStmt::_internal_is_select_into() const {
  return is_select_into_;
}
inline bool CreateTableAsStmt::is_select_into() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableAsStmt.is_select_into)
  return _internal_is_select_into();
}
inline void CreateTableAsStmt::_internal_set_is_select_into(bool value) {
  
  is_select_into_ = value;
}
inline void CreateTableAsStmt::set_is_select_into(bool value) {
  _internal_set_is_select_into(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTableAsStmt.is_select_into)
}

// bool if_not_exists = 5 [json_name = "if_not_exists"];
inline void CreateTableAsStmt::clear_if_not_exists() {
  if_not_exists_ = false;
}
inline bool CreateTableAsStmt::_internal_if_not_exists() const {
  return if_not_exists_;
}
inline bool CreateTableAsStmt::if_not_exists() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableAsStmt.if_not_exists)
  return _internal_if_not_exists();
}
inline void CreateTableAsStmt::_internal_set_if_not_exists(bool value) {
  
  if_not_exists_ = value;
}
inline void CreateTableAsStmt::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTableAsStmt.if_not_exists)
}

// -------------------------------------------------------------------

// CreateSeqStmt

// .pg_query.RangeVar sequence = 1 [json_name = "sequence"];
inline bool CreateSeqStmt::_internal_has_sequence() const {
  return this != internal_default_instance() && sequence_ != nullptr;
}
inline bool CreateSeqStmt::has_sequence() const {
  return _internal_has_sequence();
}
inline void CreateSeqStmt::clear_sequence() {
  if (GetArena() == nullptr && sequence_ != nullptr) {
    delete sequence_;
  }
  sequence_ = nullptr;
}
inline const ::pg_query::RangeVar& CreateSeqStmt::_internal_sequence() const {
  const ::pg_query::RangeVar* p = sequence_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CreateSeqStmt::sequence() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.sequence)
  return _internal_sequence();
}
inline void CreateSeqStmt::unsafe_arena_set_allocated_sequence(
    ::pg_query::RangeVar* sequence) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sequence_);
  }
  sequence_ = sequence;
  if (sequence) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateSeqStmt.sequence)
}
inline ::pg_query::RangeVar* CreateSeqStmt::release_sequence() {
  
  ::pg_query::RangeVar* temp = sequence_;
  sequence_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* CreateSeqStmt::unsafe_arena_release_sequence() {
  // @@protoc_insertion_point(field_release:pg_query.CreateSeqStmt.sequence)
  
  ::pg_query::RangeVar* temp = sequence_;
  sequence_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CreateSeqStmt::_internal_mutable_sequence() {
  
  if (sequence_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    sequence_ = p;
  }
  return sequence_;
}
inline ::pg_query::RangeVar* CreateSeqStmt::mutable_sequence() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSeqStmt.sequence)
  return _internal_mutable_sequence();
}
inline void CreateSeqStmt::set_allocated_sequence(::pg_query::RangeVar* sequence) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete sequence_;
  }
  if (sequence) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sequence);
    if (message_arena != submessage_arena) {
      sequence = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sequence, submessage_arena);
    }
    
  } else {
    
  }
  sequence_ = sequence;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateSeqStmt.sequence)
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int CreateSeqStmt::_internal_options_size() const {
  return options_.size();
}
inline int CreateSeqStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateSeqStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CreateSeqStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSeqStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateSeqStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateSeqStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CreateSeqStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CreateSeqStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CreateSeqStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CreateSeqStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreateSeqStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateSeqStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateSeqStmt.options)
  return options_;
}

// uint32 owner_id = 3 [json_name = "ownerId"];
inline void CreateSeqStmt::clear_owner_id() {
  owner_id_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CreateSeqStmt::_internal_owner_id() const {
  return owner_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CreateSeqStmt::owner_id() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.owner_id)
  return _internal_owner_id();
}
inline void CreateSeqStmt::_internal_set_owner_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  owner_id_ = value;
}
inline void CreateSeqStmt::set_owner_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_owner_id(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateSeqStmt.owner_id)
}

// bool for_identity = 4 [json_name = "for_identity"];
inline void CreateSeqStmt::clear_for_identity() {
  for_identity_ = false;
}
inline bool CreateSeqStmt::_internal_for_identity() const {
  return for_identity_;
}
inline bool CreateSeqStmt::for_identity() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.for_identity)
  return _internal_for_identity();
}
inline void CreateSeqStmt::_internal_set_for_identity(bool value) {
  
  for_identity_ = value;
}
inline void CreateSeqStmt::set_for_identity(bool value) {
  _internal_set_for_identity(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateSeqStmt.for_identity)
}

// bool if_not_exists = 5 [json_name = "if_not_exists"];
inline void CreateSeqStmt::clear_if_not_exists() {
  if_not_exists_ = false;
}
inline bool CreateSeqStmt::_internal_if_not_exists() const {
  return if_not_exists_;
}
inline bool CreateSeqStmt::if_not_exists() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.if_not_exists)
  return _internal_if_not_exists();
}
inline void CreateSeqStmt::_internal_set_if_not_exists(bool value) {
  
  if_not_exists_ = value;
}
inline void CreateSeqStmt::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateSeqStmt.if_not_exists)
}

// -------------------------------------------------------------------

// AlterSeqStmt

// .pg_query.RangeVar sequence = 1 [json_name = "sequence"];
inline bool AlterSeqStmt::_internal_has_sequence() const {
  return this != internal_default_instance() && sequence_ != nullptr;
}
inline bool AlterSeqStmt::has_sequence() const {
  return _internal_has_sequence();
}
inline void AlterSeqStmt::clear_sequence() {
  if (GetArena() == nullptr && sequence_ != nullptr) {
    delete sequence_;
  }
  sequence_ = nullptr;
}
inline const ::pg_query::RangeVar& AlterSeqStmt::_internal_sequence() const {
  const ::pg_query::RangeVar* p = sequence_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& AlterSeqStmt::sequence() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterSeqStmt.sequence)
  return _internal_sequence();
}
inline void AlterSeqStmt::unsafe_arena_set_allocated_sequence(
    ::pg_query::RangeVar* sequence) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sequence_);
  }
  sequence_ = sequence;
  if (sequence) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterSeqStmt.sequence)
}
inline ::pg_query::RangeVar* AlterSeqStmt::release_sequence() {
  
  ::pg_query::RangeVar* temp = sequence_;
  sequence_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* AlterSeqStmt::unsafe_arena_release_sequence() {
  // @@protoc_insertion_point(field_release:pg_query.AlterSeqStmt.sequence)
  
  ::pg_query::RangeVar* temp = sequence_;
  sequence_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* AlterSeqStmt::_internal_mutable_sequence() {
  
  if (sequence_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    sequence_ = p;
  }
  return sequence_;
}
inline ::pg_query::RangeVar* AlterSeqStmt::mutable_sequence() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSeqStmt.sequence)
  return _internal_mutable_sequence();
}
inline void AlterSeqStmt::set_allocated_sequence(::pg_query::RangeVar* sequence) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete sequence_;
  }
  if (sequence) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sequence);
    if (message_arena != submessage_arena) {
      sequence = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sequence, submessage_arena);
    }
    
  } else {
    
  }
  sequence_ = sequence;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterSeqStmt.sequence)
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int AlterSeqStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterSeqStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterSeqStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterSeqStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSeqStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterSeqStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterSeqStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterSeqStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterSeqStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterSeqStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterSeqStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterSeqStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterSeqStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterSeqStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterSeqStmt.options)
  return options_;
}

// bool for_identity = 3 [json_name = "for_identity"];
inline void AlterSeqStmt::clear_for_identity() {
  for_identity_ = false;
}
inline bool AlterSeqStmt::_internal_for_identity() const {
  return for_identity_;
}
inline bool AlterSeqStmt::for_identity() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterSeqStmt.for_identity)
  return _internal_for_identity();
}
inline void AlterSeqStmt::_internal_set_for_identity(bool value) {
  
  for_identity_ = value;
}
inline void AlterSeqStmt::set_for_identity(bool value) {
  _internal_set_for_identity(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterSeqStmt.for_identity)
}

// bool missing_ok = 4 [json_name = "missing_ok"];
inline void AlterSeqStmt::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool AlterSeqStmt::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool AlterSeqStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterSeqStmt.missing_ok)
  return _internal_missing_ok();
}
inline void AlterSeqStmt::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void AlterSeqStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterSeqStmt.missing_ok)
}

// -------------------------------------------------------------------

// VariableSetStmt

// .pg_query.VariableSetKind kind = 1 [json_name = "kind"];
inline void VariableSetStmt::clear_kind() {
  kind_ = 0;
}
inline ::pg_query::VariableSetKind VariableSetStmt::_internal_kind() const {
  return static_cast< ::pg_query::VariableSetKind >(kind_);
}
inline ::pg_query::VariableSetKind VariableSetStmt::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.VariableSetStmt.kind)
  return _internal_kind();
}
inline void VariableSetStmt::_internal_set_kind(::pg_query::VariableSetKind value) {
  
  kind_ = value;
}
inline void VariableSetStmt::set_kind(::pg_query::VariableSetKind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.VariableSetStmt.kind)
}

// string name = 2 [json_name = "name"];
inline void VariableSetStmt::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& VariableSetStmt::name() const {
  // @@protoc_insertion_point(field_get:pg_query.VariableSetStmt.name)
  return _internal_name();
}
inline void VariableSetStmt::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.VariableSetStmt.name)
}
inline std::string* VariableSetStmt::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.VariableSetStmt.name)
  return _internal_mutable_name();
}
inline const std::string& VariableSetStmt::_internal_name() const {
  return name_.Get();
}
inline void VariableSetStmt::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void VariableSetStmt::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.VariableSetStmt.name)
}
inline void VariableSetStmt::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.VariableSetStmt.name)
}
inline void VariableSetStmt::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.VariableSetStmt.name)
}
inline std::string* VariableSetStmt::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* VariableSetStmt::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.VariableSetStmt.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void VariableSetStmt::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.VariableSetStmt.name)
}

// repeated .pg_query.Node args = 3 [json_name = "args"];
inline int VariableSetStmt::_internal_args_size() const {
  return args_.size();
}
inline int VariableSetStmt::args_size() const {
  return _internal_args_size();
}
inline void VariableSetStmt::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* VariableSetStmt::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.VariableSetStmt.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
VariableSetStmt::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.VariableSetStmt.args)
  return &args_;
}
inline const ::pg_query::Node& VariableSetStmt::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& VariableSetStmt::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.VariableSetStmt.args)
  return _internal_args(index);
}
inline ::pg_query::Node* VariableSetStmt::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* VariableSetStmt::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.VariableSetStmt.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
VariableSetStmt::args() const {
  // @@protoc_insertion_point(field_list:pg_query.VariableSetStmt.args)
  return args_;
}

// bool is_local = 4 [json_name = "is_local"];
inline void VariableSetStmt::clear_is_local() {
  is_local_ = false;
}
inline bool VariableSetStmt::_internal_is_local() const {
  return is_local_;
}
inline bool VariableSetStmt::is_local() const {
  // @@protoc_insertion_point(field_get:pg_query.VariableSetStmt.is_local)
  return _internal_is_local();
}
inline void VariableSetStmt::_internal_set_is_local(bool value) {
  
  is_local_ = value;
}
inline void VariableSetStmt::set_is_local(bool value) {
  _internal_set_is_local(value);
  // @@protoc_insertion_point(field_set:pg_query.VariableSetStmt.is_local)
}

// -------------------------------------------------------------------

// VariableShowStmt

// string name = 1 [json_name = "name"];
inline void VariableShowStmt::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& VariableShowStmt::name() const {
  // @@protoc_insertion_point(field_get:pg_query.VariableShowStmt.name)
  return _internal_name();
}
inline void VariableShowStmt::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.VariableShowStmt.name)
}
inline std::string* VariableShowStmt::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.VariableShowStmt.name)
  return _internal_mutable_name();
}
inline const std::string& VariableShowStmt::_internal_name() const {
  return name_.Get();
}
inline void VariableShowStmt::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void VariableShowStmt::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.VariableShowStmt.name)
}
inline void VariableShowStmt::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.VariableShowStmt.name)
}
inline void VariableShowStmt::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.VariableShowStmt.name)
}
inline std::string* VariableShowStmt::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* VariableShowStmt::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.VariableShowStmt.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void VariableShowStmt::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.VariableShowStmt.name)
}

// -------------------------------------------------------------------

// DiscardStmt

// .pg_query.DiscardMode target = 1 [json_name = "target"];
inline void DiscardStmt::clear_target() {
  target_ = 0;
}
inline ::pg_query::DiscardMode DiscardStmt::_internal_target() const {
  return static_cast< ::pg_query::DiscardMode >(target_);
}
inline ::pg_query::DiscardMode DiscardStmt::target() const {
  // @@protoc_insertion_point(field_get:pg_query.DiscardStmt.target)
  return _internal_target();
}
inline void DiscardStmt::_internal_set_target(::pg_query::DiscardMode value) {
  
  target_ = value;
}
inline void DiscardStmt::set_target(::pg_query::DiscardMode value) {
  _internal_set_target(value);
  // @@protoc_insertion_point(field_set:pg_query.DiscardStmt.target)
}

// -------------------------------------------------------------------

// CreateTrigStmt

// string trigname = 1 [json_name = "trigname"];
inline void CreateTrigStmt::clear_trigname() {
  trigname_.ClearToEmpty();
}
inline const std::string& CreateTrigStmt::trigname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.trigname)
  return _internal_trigname();
}
inline void CreateTrigStmt::set_trigname(const std::string& value) {
  _internal_set_trigname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.trigname)
}
inline std::string* CreateTrigStmt::mutable_trigname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.trigname)
  return _internal_mutable_trigname();
}
inline const std::string& CreateTrigStmt::_internal_trigname() const {
  return trigname_.Get();
}
inline void CreateTrigStmt::_internal_set_trigname(const std::string& value) {
  
  trigname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateTrigStmt::set_trigname(std::string&& value) {
  
  trigname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateTrigStmt.trigname)
}
inline void CreateTrigStmt::set_trigname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  trigname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateTrigStmt.trigname)
}
inline void CreateTrigStmt::set_trigname(const char* value,
    size_t size) {
  
  trigname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateTrigStmt.trigname)
}
inline std::string* CreateTrigStmt::_internal_mutable_trigname() {
  
  return trigname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateTrigStmt::release_trigname() {
  // @@protoc_insertion_point(field_release:pg_query.CreateTrigStmt.trigname)
  return trigname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateTrigStmt::set_allocated_trigname(std::string* trigname) {
  if (trigname != nullptr) {
    
  } else {
    
  }
  trigname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), trigname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTrigStmt.trigname)
}

// .pg_query.RangeVar relation = 2 [json_name = "relation"];
inline bool CreateTrigStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool CreateTrigStmt::has_relation() const {
  return _internal_has_relation();
}
inline void CreateTrigStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& CreateTrigStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CreateTrigStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.relation)
  return _internal_relation();
}
inline void CreateTrigStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTrigStmt.relation)
}
inline ::pg_query::RangeVar* CreateTrigStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* CreateTrigStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.CreateTrigStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CreateTrigStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* CreateTrigStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.relation)
  return _internal_mutable_relation();
}
inline void CreateTrigStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTrigStmt.relation)
}

// repeated .pg_query.Node funcname = 3 [json_name = "funcname"];
inline int CreateTrigStmt::_internal_funcname_size() const {
  return funcname_.size();
}
inline int CreateTrigStmt::funcname_size() const {
  return _internal_funcname_size();
}
inline void CreateTrigStmt::clear_funcname() {
  funcname_.Clear();
}
inline ::pg_query::Node* CreateTrigStmt::mutable_funcname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.funcname)
  return funcname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateTrigStmt::mutable_funcname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTrigStmt.funcname)
  return &funcname_;
}
inline const ::pg_query::Node& CreateTrigStmt::_internal_funcname(int index) const {
  return funcname_.Get(index);
}
inline const ::pg_query::Node& CreateTrigStmt::funcname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.funcname)
  return _internal_funcname(index);
}
inline ::pg_query::Node* CreateTrigStmt::_internal_add_funcname() {
  return funcname_.Add();
}
inline ::pg_query::Node* CreateTrigStmt::add_funcname() {
  // @@protoc_insertion_point(field_add:pg_query.CreateTrigStmt.funcname)
  return _internal_add_funcname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateTrigStmt::funcname() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateTrigStmt.funcname)
  return funcname_;
}

// repeated .pg_query.Node args = 4 [json_name = "args"];
inline int CreateTrigStmt::_internal_args_size() const {
  return args_.size();
}
inline int CreateTrigStmt::args_size() const {
  return _internal_args_size();
}
inline void CreateTrigStmt::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* CreateTrigStmt::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateTrigStmt::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTrigStmt.args)
  return &args_;
}
inline const ::pg_query::Node& CreateTrigStmt::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& CreateTrigStmt::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.args)
  return _internal_args(index);
}
inline ::pg_query::Node* CreateTrigStmt::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* CreateTrigStmt::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.CreateTrigStmt.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateTrigStmt::args() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateTrigStmt.args)
  return args_;
}

// bool row = 5 [json_name = "row"];
inline void CreateTrigStmt::clear_row() {
  row_ = false;
}
inline bool CreateTrigStmt::_internal_row() const {
  return row_;
}
inline bool CreateTrigStmt::row() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.row)
  return _internal_row();
}
inline void CreateTrigStmt::_internal_set_row(bool value) {
  
  row_ = value;
}
inline void CreateTrigStmt::set_row(bool value) {
  _internal_set_row(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.row)
}

// int32 timing = 6 [json_name = "timing"];
inline void CreateTrigStmt::clear_timing() {
  timing_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CreateTrigStmt::_internal_timing() const {
  return timing_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CreateTrigStmt::timing() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.timing)
  return _internal_timing();
}
inline void CreateTrigStmt::_internal_set_timing(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  timing_ = value;
}
inline void CreateTrigStmt::set_timing(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_timing(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.timing)
}

// int32 events = 7 [json_name = "events"];
inline void CreateTrigStmt::clear_events() {
  events_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CreateTrigStmt::_internal_events() const {
  return events_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CreateTrigStmt::events() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.events)
  return _internal_events();
}
inline void CreateTrigStmt::_internal_set_events(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  events_ = value;
}
inline void CreateTrigStmt::set_events(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_events(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.events)
}

// repeated .pg_query.Node columns = 8 [json_name = "columns"];
inline int CreateTrigStmt::_internal_columns_size() const {
  return columns_.size();
}
inline int CreateTrigStmt::columns_size() const {
  return _internal_columns_size();
}
inline void CreateTrigStmt::clear_columns() {
  columns_.Clear();
}
inline ::pg_query::Node* CreateTrigStmt::mutable_columns(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.columns)
  return columns_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateTrigStmt::mutable_columns() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTrigStmt.columns)
  return &columns_;
}
inline const ::pg_query::Node& CreateTrigStmt::_internal_columns(int index) const {
  return columns_.Get(index);
}
inline const ::pg_query::Node& CreateTrigStmt::columns(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.columns)
  return _internal_columns(index);
}
inline ::pg_query::Node* CreateTrigStmt::_internal_add_columns() {
  return columns_.Add();
}
inline ::pg_query::Node* CreateTrigStmt::add_columns() {
  // @@protoc_insertion_point(field_add:pg_query.CreateTrigStmt.columns)
  return _internal_add_columns();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateTrigStmt::columns() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateTrigStmt.columns)
  return columns_;
}

// .pg_query.Node when_clause = 9 [json_name = "whenClause"];
inline bool CreateTrigStmt::_internal_has_when_clause() const {
  return this != internal_default_instance() && when_clause_ != nullptr;
}
inline bool CreateTrigStmt::has_when_clause() const {
  return _internal_has_when_clause();
}
inline void CreateTrigStmt::clear_when_clause() {
  if (GetArena() == nullptr && when_clause_ != nullptr) {
    delete when_clause_;
  }
  when_clause_ = nullptr;
}
inline const ::pg_query::Node& CreateTrigStmt::_internal_when_clause() const {
  const ::pg_query::Node* p = when_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CreateTrigStmt::when_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.when_clause)
  return _internal_when_clause();
}
inline void CreateTrigStmt::unsafe_arena_set_allocated_when_clause(
    ::pg_query::Node* when_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(when_clause_);
  }
  when_clause_ = when_clause;
  if (when_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTrigStmt.when_clause)
}
inline ::pg_query::Node* CreateTrigStmt::release_when_clause() {
  
  ::pg_query::Node* temp = when_clause_;
  when_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CreateTrigStmt::unsafe_arena_release_when_clause() {
  // @@protoc_insertion_point(field_release:pg_query.CreateTrigStmt.when_clause)
  
  ::pg_query::Node* temp = when_clause_;
  when_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CreateTrigStmt::_internal_mutable_when_clause() {
  
  if (when_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    when_clause_ = p;
  }
  return when_clause_;
}
inline ::pg_query::Node* CreateTrigStmt::mutable_when_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.when_clause)
  return _internal_mutable_when_clause();
}
inline void CreateTrigStmt::set_allocated_when_clause(::pg_query::Node* when_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete when_clause_;
  }
  if (when_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(when_clause);
    if (message_arena != submessage_arena) {
      when_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, when_clause, submessage_arena);
    }
    
  } else {
    
  }
  when_clause_ = when_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTrigStmt.when_clause)
}

// bool isconstraint = 10 [json_name = "isconstraint"];
inline void CreateTrigStmt::clear_isconstraint() {
  isconstraint_ = false;
}
inline bool CreateTrigStmt::_internal_isconstraint() const {
  return isconstraint_;
}
inline bool CreateTrigStmt::isconstraint() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.isconstraint)
  return _internal_isconstraint();
}
inline void CreateTrigStmt::_internal_set_isconstraint(bool value) {
  
  isconstraint_ = value;
}
inline void CreateTrigStmt::set_isconstraint(bool value) {
  _internal_set_isconstraint(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.isconstraint)
}

// repeated .pg_query.Node transition_rels = 11 [json_name = "transitionRels"];
inline int CreateTrigStmt::_internal_transition_rels_size() const {
  return transition_rels_.size();
}
inline int CreateTrigStmt::transition_rels_size() const {
  return _internal_transition_rels_size();
}
inline void CreateTrigStmt::clear_transition_rels() {
  transition_rels_.Clear();
}
inline ::pg_query::Node* CreateTrigStmt::mutable_transition_rels(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.transition_rels)
  return transition_rels_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateTrigStmt::mutable_transition_rels() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTrigStmt.transition_rels)
  return &transition_rels_;
}
inline const ::pg_query::Node& CreateTrigStmt::_internal_transition_rels(int index) const {
  return transition_rels_.Get(index);
}
inline const ::pg_query::Node& CreateTrigStmt::transition_rels(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.transition_rels)
  return _internal_transition_rels(index);
}
inline ::pg_query::Node* CreateTrigStmt::_internal_add_transition_rels() {
  return transition_rels_.Add();
}
inline ::pg_query::Node* CreateTrigStmt::add_transition_rels() {
  // @@protoc_insertion_point(field_add:pg_query.CreateTrigStmt.transition_rels)
  return _internal_add_transition_rels();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateTrigStmt::transition_rels() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateTrigStmt.transition_rels)
  return transition_rels_;
}

// bool deferrable = 12 [json_name = "deferrable"];
inline void CreateTrigStmt::clear_deferrable() {
  deferrable_ = false;
}
inline bool CreateTrigStmt::_internal_deferrable() const {
  return deferrable_;
}
inline bool CreateTrigStmt::deferrable() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.deferrable)
  return _internal_deferrable();
}
inline void CreateTrigStmt::_internal_set_deferrable(bool value) {
  
  deferrable_ = value;
}
inline void CreateTrigStmt::set_deferrable(bool value) {
  _internal_set_deferrable(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.deferrable)
}

// bool initdeferred = 13 [json_name = "initdeferred"];
inline void CreateTrigStmt::clear_initdeferred() {
  initdeferred_ = false;
}
inline bool CreateTrigStmt::_internal_initdeferred() const {
  return initdeferred_;
}
inline bool CreateTrigStmt::initdeferred() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.initdeferred)
  return _internal_initdeferred();
}
inline void CreateTrigStmt::_internal_set_initdeferred(bool value) {
  
  initdeferred_ = value;
}
inline void CreateTrigStmt::set_initdeferred(bool value) {
  _internal_set_initdeferred(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.initdeferred)
}

// .pg_query.RangeVar constrrel = 14 [json_name = "constrrel"];
inline bool CreateTrigStmt::_internal_has_constrrel() const {
  return this != internal_default_instance() && constrrel_ != nullptr;
}
inline bool CreateTrigStmt::has_constrrel() const {
  return _internal_has_constrrel();
}
inline void CreateTrigStmt::clear_constrrel() {
  if (GetArena() == nullptr && constrrel_ != nullptr) {
    delete constrrel_;
  }
  constrrel_ = nullptr;
}
inline const ::pg_query::RangeVar& CreateTrigStmt::_internal_constrrel() const {
  const ::pg_query::RangeVar* p = constrrel_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CreateTrigStmt::constrrel() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.constrrel)
  return _internal_constrrel();
}
inline void CreateTrigStmt::unsafe_arena_set_allocated_constrrel(
    ::pg_query::RangeVar* constrrel) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(constrrel_);
  }
  constrrel_ = constrrel;
  if (constrrel) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTrigStmt.constrrel)
}
inline ::pg_query::RangeVar* CreateTrigStmt::release_constrrel() {
  
  ::pg_query::RangeVar* temp = constrrel_;
  constrrel_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* CreateTrigStmt::unsafe_arena_release_constrrel() {
  // @@protoc_insertion_point(field_release:pg_query.CreateTrigStmt.constrrel)
  
  ::pg_query::RangeVar* temp = constrrel_;
  constrrel_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CreateTrigStmt::_internal_mutable_constrrel() {
  
  if (constrrel_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    constrrel_ = p;
  }
  return constrrel_;
}
inline ::pg_query::RangeVar* CreateTrigStmt::mutable_constrrel() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.constrrel)
  return _internal_mutable_constrrel();
}
inline void CreateTrigStmt::set_allocated_constrrel(::pg_query::RangeVar* constrrel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete constrrel_;
  }
  if (constrrel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(constrrel);
    if (message_arena != submessage_arena) {
      constrrel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, constrrel, submessage_arena);
    }
    
  } else {
    
  }
  constrrel_ = constrrel;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTrigStmt.constrrel)
}

// -------------------------------------------------------------------

// CreatePLangStmt

// bool replace = 1 [json_name = "replace"];
inline void CreatePLangStmt::clear_replace() {
  replace_ = false;
}
inline bool CreatePLangStmt::_internal_replace() const {
  return replace_;
}
inline bool CreatePLangStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.replace)
  return _internal_replace();
}
inline void CreatePLangStmt::_internal_set_replace(bool value) {
  
  replace_ = value;
}
inline void CreatePLangStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.CreatePLangStmt.replace)
}

// string plname = 2 [json_name = "plname"];
inline void CreatePLangStmt::clear_plname() {
  plname_.ClearToEmpty();
}
inline const std::string& CreatePLangStmt::plname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.plname)
  return _internal_plname();
}
inline void CreatePLangStmt::set_plname(const std::string& value) {
  _internal_set_plname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreatePLangStmt.plname)
}
inline std::string* CreatePLangStmt::mutable_plname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePLangStmt.plname)
  return _internal_mutable_plname();
}
inline const std::string& CreatePLangStmt::_internal_plname() const {
  return plname_.Get();
}
inline void CreatePLangStmt::_internal_set_plname(const std::string& value) {
  
  plname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreatePLangStmt::set_plname(std::string&& value) {
  
  plname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreatePLangStmt.plname)
}
inline void CreatePLangStmt::set_plname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  plname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreatePLangStmt.plname)
}
inline void CreatePLangStmt::set_plname(const char* value,
    size_t size) {
  
  plname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreatePLangStmt.plname)
}
inline std::string* CreatePLangStmt::_internal_mutable_plname() {
  
  return plname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreatePLangStmt::release_plname() {
  // @@protoc_insertion_point(field_release:pg_query.CreatePLangStmt.plname)
  return plname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreatePLangStmt::set_allocated_plname(std::string* plname) {
  if (plname != nullptr) {
    
  } else {
    
  }
  plname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), plname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePLangStmt.plname)
}

// repeated .pg_query.Node plhandler = 3 [json_name = "plhandler"];
inline int CreatePLangStmt::_internal_plhandler_size() const {
  return plhandler_.size();
}
inline int CreatePLangStmt::plhandler_size() const {
  return _internal_plhandler_size();
}
inline void CreatePLangStmt::clear_plhandler() {
  plhandler_.Clear();
}
inline ::pg_query::Node* CreatePLangStmt::mutable_plhandler(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePLangStmt.plhandler)
  return plhandler_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreatePLangStmt::mutable_plhandler() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePLangStmt.plhandler)
  return &plhandler_;
}
inline const ::pg_query::Node& CreatePLangStmt::_internal_plhandler(int index) const {
  return plhandler_.Get(index);
}
inline const ::pg_query::Node& CreatePLangStmt::plhandler(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.plhandler)
  return _internal_plhandler(index);
}
inline ::pg_query::Node* CreatePLangStmt::_internal_add_plhandler() {
  return plhandler_.Add();
}
inline ::pg_query::Node* CreatePLangStmt::add_plhandler() {
  // @@protoc_insertion_point(field_add:pg_query.CreatePLangStmt.plhandler)
  return _internal_add_plhandler();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreatePLangStmt::plhandler() const {
  // @@protoc_insertion_point(field_list:pg_query.CreatePLangStmt.plhandler)
  return plhandler_;
}

// repeated .pg_query.Node plinline = 4 [json_name = "plinline"];
inline int CreatePLangStmt::_internal_plinline_size() const {
  return plinline_.size();
}
inline int CreatePLangStmt::plinline_size() const {
  return _internal_plinline_size();
}
inline void CreatePLangStmt::clear_plinline() {
  plinline_.Clear();
}
inline ::pg_query::Node* CreatePLangStmt::mutable_plinline(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePLangStmt.plinline)
  return plinline_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreatePLangStmt::mutable_plinline() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePLangStmt.plinline)
  return &plinline_;
}
inline const ::pg_query::Node& CreatePLangStmt::_internal_plinline(int index) const {
  return plinline_.Get(index);
}
inline const ::pg_query::Node& CreatePLangStmt::plinline(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.plinline)
  return _internal_plinline(index);
}
inline ::pg_query::Node* CreatePLangStmt::_internal_add_plinline() {
  return plinline_.Add();
}
inline ::pg_query::Node* CreatePLangStmt::add_plinline() {
  // @@protoc_insertion_point(field_add:pg_query.CreatePLangStmt.plinline)
  return _internal_add_plinline();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreatePLangStmt::plinline() const {
  // @@protoc_insertion_point(field_list:pg_query.CreatePLangStmt.plinline)
  return plinline_;
}

// repeated .pg_query.Node plvalidator = 5 [json_name = "plvalidator"];
inline int CreatePLangStmt::_internal_plvalidator_size() const {
  return plvalidator_.size();
}
inline int CreatePLangStmt::plvalidator_size() const {
  return _internal_plvalidator_size();
}
inline void CreatePLangStmt::clear_plvalidator() {
  plvalidator_.Clear();
}
inline ::pg_query::Node* CreatePLangStmt::mutable_plvalidator(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePLangStmt.plvalidator)
  return plvalidator_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreatePLangStmt::mutable_plvalidator() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePLangStmt.plvalidator)
  return &plvalidator_;
}
inline const ::pg_query::Node& CreatePLangStmt::_internal_plvalidator(int index) const {
  return plvalidator_.Get(index);
}
inline const ::pg_query::Node& CreatePLangStmt::plvalidator(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.plvalidator)
  return _internal_plvalidator(index);
}
inline ::pg_query::Node* CreatePLangStmt::_internal_add_plvalidator() {
  return plvalidator_.Add();
}
inline ::pg_query::Node* CreatePLangStmt::add_plvalidator() {
  // @@protoc_insertion_point(field_add:pg_query.CreatePLangStmt.plvalidator)
  return _internal_add_plvalidator();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreatePLangStmt::plvalidator() const {
  // @@protoc_insertion_point(field_list:pg_query.CreatePLangStmt.plvalidator)
  return plvalidator_;
}

// bool pltrusted = 6 [json_name = "pltrusted"];
inline void CreatePLangStmt::clear_pltrusted() {
  pltrusted_ = false;
}
inline bool CreatePLangStmt::_internal_pltrusted() const {
  return pltrusted_;
}
inline bool CreatePLangStmt::pltrusted() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.pltrusted)
  return _internal_pltrusted();
}
inline void CreatePLangStmt::_internal_set_pltrusted(bool value) {
  
  pltrusted_ = value;
}
inline void CreatePLangStmt::set_pltrusted(bool value) {
  _internal_set_pltrusted(value);
  // @@protoc_insertion_point(field_set:pg_query.CreatePLangStmt.pltrusted)
}

// -------------------------------------------------------------------

// CreateRoleStmt

// .pg_query.RoleStmtType stmt_type = 1 [json_name = "stmt_type"];
inline void CreateRoleStmt::clear_stmt_type() {
  stmt_type_ = 0;
}
inline ::pg_query::RoleStmtType CreateRoleStmt::_internal_stmt_type() const {
  return static_cast< ::pg_query::RoleStmtType >(stmt_type_);
}
inline ::pg_query::RoleStmtType CreateRoleStmt::stmt_type() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateRoleStmt.stmt_type)
  return _internal_stmt_type();
}
inline void CreateRoleStmt::_internal_set_stmt_type(::pg_query::RoleStmtType value) {
  
  stmt_type_ = value;
}
inline void CreateRoleStmt::set_stmt_type(::pg_query::RoleStmtType value) {
  _internal_set_stmt_type(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateRoleStmt.stmt_type)
}

// string role = 2 [json_name = "role"];
inline void CreateRoleStmt::clear_role() {
  role_.ClearToEmpty();
}
inline const std::string& CreateRoleStmt::role() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateRoleStmt.role)
  return _internal_role();
}
inline void CreateRoleStmt::set_role(const std::string& value) {
  _internal_set_role(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateRoleStmt.role)
}
inline std::string* CreateRoleStmt::mutable_role() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateRoleStmt.role)
  return _internal_mutable_role();
}
inline const std::string& CreateRoleStmt::_internal_role() const {
  return role_.Get();
}
inline void CreateRoleStmt::_internal_set_role(const std::string& value) {
  
  role_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateRoleStmt::set_role(std::string&& value) {
  
  role_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateRoleStmt.role)
}
inline void CreateRoleStmt::set_role(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  role_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateRoleStmt.role)
}
inline void CreateRoleStmt::set_role(const char* value,
    size_t size) {
  
  role_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateRoleStmt.role)
}
inline std::string* CreateRoleStmt::_internal_mutable_role() {
  
  return role_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateRoleStmt::release_role() {
  // @@protoc_insertion_point(field_release:pg_query.CreateRoleStmt.role)
  return role_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateRoleStmt::set_allocated_role(std::string* role) {
  if (role != nullptr) {
    
  } else {
    
  }
  role_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), role,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateRoleStmt.role)
}

// repeated .pg_query.Node options = 3 [json_name = "options"];
inline int CreateRoleStmt::_internal_options_size() const {
  return options_.size();
}
inline int CreateRoleStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateRoleStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CreateRoleStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateRoleStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateRoleStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateRoleStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CreateRoleStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CreateRoleStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateRoleStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CreateRoleStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CreateRoleStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreateRoleStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateRoleStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateRoleStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// AlterRoleStmt

// .pg_query.RoleSpec role = 1 [json_name = "role"];
inline bool AlterRoleStmt::_internal_has_role() const {
  return this != internal_default_instance() && role_ != nullptr;
}
inline bool AlterRoleStmt::has_role() const {
  return _internal_has_role();
}
inline void AlterRoleStmt::clear_role() {
  if (GetArena() == nullptr && role_ != nullptr) {
    delete role_;
  }
  role_ = nullptr;
}
inline const ::pg_query::RoleSpec& AlterRoleStmt::_internal_role() const {
  const ::pg_query::RoleSpec* p = role_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(
      ::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& AlterRoleStmt::role() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterRoleStmt.role)
  return _internal_role();
}
inline void AlterRoleStmt::unsafe_arena_set_allocated_role(
    ::pg_query::RoleSpec* role) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(role_);
  }
  role_ = role;
  if (role) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterRoleStmt.role)
}
inline ::pg_query::RoleSpec* AlterRoleStmt::release_role() {
  
  ::pg_query::RoleSpec* temp = role_;
  role_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RoleSpec* AlterRoleStmt::unsafe_arena_release_role() {
  // @@protoc_insertion_point(field_release:pg_query.AlterRoleStmt.role)
  
  ::pg_query::RoleSpec* temp = role_;
  role_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* AlterRoleStmt::_internal_mutable_role() {
  
  if (role_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    role_ = p;
  }
  return role_;
}
inline ::pg_query::RoleSpec* AlterRoleStmt::mutable_role() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterRoleStmt.role)
  return _internal_mutable_role();
}
inline void AlterRoleStmt::set_allocated_role(::pg_query::RoleSpec* role) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete role_;
  }
  if (role) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(role);
    if (message_arena != submessage_arena) {
      role = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, role, submessage_arena);
    }
    
  } else {
    
  }
  role_ = role;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterRoleStmt.role)
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int AlterRoleStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterRoleStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterRoleStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterRoleStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterRoleStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterRoleStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterRoleStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterRoleStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterRoleStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterRoleStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterRoleStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterRoleStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterRoleStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterRoleStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterRoleStmt.options)
  return options_;
}

// int32 action = 3 [json_name = "action"];
inline void AlterRoleStmt::clear_action() {
  action_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 AlterRoleStmt::_internal_action() const {
  return action_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 AlterRoleStmt::action() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterRoleStmt.action)
  return _internal_action();
}
inline void AlterRoleStmt::_internal_set_action(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  action_ = value;
}
inline void AlterRoleStmt::set_action(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterRoleStmt.action)
}

// -------------------------------------------------------------------

// DropRoleStmt

// repeated .pg_query.Node roles = 1 [json_name = "roles"];
inline int DropRoleStmt::_internal_roles_size() const {
  return roles_.size();
}
inline int DropRoleStmt::roles_size() const {
  return _internal_roles_size();
}
inline void DropRoleStmt::clear_roles() {
  roles_.Clear();
}
inline ::pg_query::Node* DropRoleStmt::mutable_roles(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.DropRoleStmt.roles)
  return roles_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
DropRoleStmt::mutable_roles() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DropRoleStmt.roles)
  return &roles_;
}
inline const ::pg_query::Node& DropRoleStmt::_internal_roles(int index) const {
  return roles_.Get(index);
}
inline const ::pg_query::Node& DropRoleStmt::roles(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.DropRoleStmt.roles)
  return _internal_roles(index);
}
inline ::pg_query::Node* DropRoleStmt::_internal_add_roles() {
  return roles_.Add();
}
inline ::pg_query::Node* DropRoleStmt::add_roles() {
  // @@protoc_insertion_point(field_add:pg_query.DropRoleStmt.roles)
  return _internal_add_roles();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
DropRoleStmt::roles() const {
  // @@protoc_insertion_point(field_list:pg_query.DropRoleStmt.roles)
  return roles_;
}

// bool missing_ok = 2 [json_name = "missing_ok"];
inline void DropRoleStmt::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool DropRoleStmt::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool DropRoleStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.DropRoleStmt.missing_ok)
  return _internal_missing_ok();
}
inline void DropRoleStmt::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void DropRoleStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.DropRoleStmt.missing_ok)
}

// -------------------------------------------------------------------

// LockStmt

// repeated .pg_query.Node relations = 1 [json_name = "relations"];
inline int LockStmt::_internal_relations_size() const {
  return relations_.size();
}
inline int LockStmt::relations_size() const {
  return _internal_relations_size();
}
inline void LockStmt::clear_relations() {
  relations_.Clear();
}
inline ::pg_query::Node* LockStmt::mutable_relations(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.LockStmt.relations)
  return relations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
LockStmt::mutable_relations() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.LockStmt.relations)
  return &relations_;
}
inline const ::pg_query::Node& LockStmt::_internal_relations(int index) const {
  return relations_.Get(index);
}
inline const ::pg_query::Node& LockStmt::relations(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.LockStmt.relations)
  return _internal_relations(index);
}
inline ::pg_query::Node* LockStmt::_internal_add_relations() {
  return relations_.Add();
}
inline ::pg_query::Node* LockStmt::add_relations() {
  // @@protoc_insertion_point(field_add:pg_query.LockStmt.relations)
  return _internal_add_relations();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
LockStmt::relations() const {
  // @@protoc_insertion_point(field_list:pg_query.LockStmt.relations)
  return relations_;
}

// int32 mode = 2 [json_name = "mode"];
inline void LockStmt::clear_mode() {
  mode_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LockStmt::_internal_mode() const {
  return mode_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LockStmt::mode() const {
  // @@protoc_insertion_point(field_get:pg_query.LockStmt.mode)
  return _internal_mode();
}
inline void LockStmt::_internal_set_mode(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  mode_ = value;
}
inline void LockStmt::set_mode(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_mode(value);
  // @@protoc_insertion_point(field_set:pg_query.LockStmt.mode)
}

// bool nowait = 3 [json_name = "nowait"];
inline void LockStmt::clear_nowait() {
  nowait_ = false;
}
inline bool LockStmt::_internal_nowait() const {
  return nowait_;
}
inline bool LockStmt::nowait() const {
  // @@protoc_insertion_point(field_get:pg_query.LockStmt.nowait)
  return _internal_nowait();
}
inline void LockStmt::_internal_set_nowait(bool value) {
  
  nowait_ = value;
}
inline void LockStmt::set_nowait(bool value) {
  _internal_set_nowait(value);
  // @@protoc_insertion_point(field_set:pg_query.LockStmt.nowait)
}

// -------------------------------------------------------------------

// ConstraintsSetStmt

// repeated .pg_query.Node constraints = 1 [json_name = "constraints"];
inline int ConstraintsSetStmt::_internal_constraints_size() const {
  return constraints_.size();
}
inline int ConstraintsSetStmt::constraints_size() const {
  return _internal_constraints_size();
}
inline void ConstraintsSetStmt::clear_constraints() {
  constraints_.Clear();
}
inline ::pg_query::Node* ConstraintsSetStmt::mutable_constraints(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ConstraintsSetStmt.constraints)
  return constraints_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ConstraintsSetStmt::mutable_constraints() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ConstraintsSetStmt.constraints)
  return &constraints_;
}
inline const ::pg_query::Node& ConstraintsSetStmt::_internal_constraints(int index) const {
  return constraints_.Get(index);
}
inline const ::pg_query::Node& ConstraintsSetStmt::constraints(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ConstraintsSetStmt.constraints)
  return _internal_constraints(index);
}
inline ::pg_query::Node* ConstraintsSetStmt::_internal_add_constraints() {
  return constraints_.Add();
}
inline ::pg_query::Node* ConstraintsSetStmt::add_constraints() {
  // @@protoc_insertion_point(field_add:pg_query.ConstraintsSetStmt.constraints)
  return _internal_add_constraints();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ConstraintsSetStmt::constraints() const {
  // @@protoc_insertion_point(field_list:pg_query.ConstraintsSetStmt.constraints)
  return constraints_;
}

// bool deferred = 2 [json_name = "deferred"];
inline void ConstraintsSetStmt::clear_deferred() {
  deferred_ = false;
}
inline bool ConstraintsSetStmt::_internal_deferred() const {
  return deferred_;
}
inline bool ConstraintsSetStmt::deferred() const {
  // @@protoc_insertion_point(field_get:pg_query.ConstraintsSetStmt.deferred)
  return _internal_deferred();
}
inline void ConstraintsSetStmt::_internal_set_deferred(bool value) {
  
  deferred_ = value;
}
inline void ConstraintsSetStmt::set_deferred(bool value) {
  _internal_set_deferred(value);
  // @@protoc_insertion_point(field_set:pg_query.ConstraintsSetStmt.deferred)
}

// -------------------------------------------------------------------

// ReindexStmt

// .pg_query.ReindexObjectType kind = 1 [json_name = "kind"];
inline void ReindexStmt::clear_kind() {
  kind_ = 0;
}
inline ::pg_query::ReindexObjectType ReindexStmt::_internal_kind() const {
  return static_cast< ::pg_query::ReindexObjectType >(kind_);
}
inline ::pg_query::ReindexObjectType ReindexStmt::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.ReindexStmt.kind)
  return _internal_kind();
}
inline void ReindexStmt::_internal_set_kind(::pg_query::ReindexObjectType value) {
  
  kind_ = value;
}
inline void ReindexStmt::set_kind(::pg_query::ReindexObjectType value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.ReindexStmt.kind)
}

// .pg_query.RangeVar relation = 2 [json_name = "relation"];
inline bool ReindexStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool ReindexStmt::has_relation() const {
  return _internal_has_relation();
}
inline void ReindexStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& ReindexStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& ReindexStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.ReindexStmt.relation)
  return _internal_relation();
}
inline void ReindexStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ReindexStmt.relation)
}
inline ::pg_query::RangeVar* ReindexStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* ReindexStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.ReindexStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* ReindexStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* ReindexStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.ReindexStmt.relation)
  return _internal_mutable_relation();
}
inline void ReindexStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ReindexStmt.relation)
}

// string name = 3 [json_name = "name"];
inline void ReindexStmt::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& ReindexStmt::name() const {
  // @@protoc_insertion_point(field_get:pg_query.ReindexStmt.name)
  return _internal_name();
}
inline void ReindexStmt::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.ReindexStmt.name)
}
inline std::string* ReindexStmt::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.ReindexStmt.name)
  return _internal_mutable_name();
}
inline const std::string& ReindexStmt::_internal_name() const {
  return name_.Get();
}
inline void ReindexStmt::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ReindexStmt::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ReindexStmt.name)
}
inline void ReindexStmt::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ReindexStmt.name)
}
inline void ReindexStmt::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ReindexStmt.name)
}
inline std::string* ReindexStmt::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ReindexStmt::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.ReindexStmt.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ReindexStmt::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ReindexStmt.name)
}

// int32 options = 4 [json_name = "options"];
inline void ReindexStmt::clear_options() {
  options_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ReindexStmt::_internal_options() const {
  return options_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ReindexStmt::options() const {
  // @@protoc_insertion_point(field_get:pg_query.ReindexStmt.options)
  return _internal_options();
}
inline void ReindexStmt::_internal_set_options(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  options_ = value;
}
inline void ReindexStmt::set_options(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_options(value);
  // @@protoc_insertion_point(field_set:pg_query.ReindexStmt.options)
}

// bool concurrent = 5 [json_name = "concurrent"];
inline void ReindexStmt::clear_concurrent() {
  concurrent_ = false;
}
inline bool ReindexStmt::_internal_concurrent() const {
  return concurrent_;
}
inline bool ReindexStmt::concurrent() const {
  // @@protoc_insertion_point(field_get:pg_query.ReindexStmt.concurrent)
  return _internal_concurrent();
}
inline void ReindexStmt::_internal_set_concurrent(bool value) {
  
  concurrent_ = value;
}
inline void ReindexStmt::set_concurrent(bool value) {
  _internal_set_concurrent(value);
  // @@protoc_insertion_point(field_set:pg_query.ReindexStmt.concurrent)
}

// -------------------------------------------------------------------

// CheckPointStmt

// -------------------------------------------------------------------

// CreateSchemaStmt

// string schemaname = 1 [json_name = "schemaname"];
inline void CreateSchemaStmt::clear_schemaname() {
  schemaname_.ClearToEmpty();
}
inline const std::string& CreateSchemaStmt::schemaname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSchemaStmt.schemaname)
  return _internal_schemaname();
}
inline void CreateSchemaStmt::set_schemaname(const std::string& value) {
  _internal_set_schemaname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateSchemaStmt.schemaname)
}
inline std::string* CreateSchemaStmt::mutable_schemaname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSchemaStmt.schemaname)
  return _internal_mutable_schemaname();
}
inline const std::string& CreateSchemaStmt::_internal_schemaname() const {
  return schemaname_.Get();
}
inline void CreateSchemaStmt::_internal_set_schemaname(const std::string& value) {
  
  schemaname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateSchemaStmt::set_schemaname(std::string&& value) {
  
  schemaname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateSchemaStmt.schemaname)
}
inline void CreateSchemaStmt::set_schemaname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  schemaname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateSchemaStmt.schemaname)
}
inline void CreateSchemaStmt::set_schemaname(const char* value,
    size_t size) {
  
  schemaname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateSchemaStmt.schemaname)
}
inline std::string* CreateSchemaStmt::_internal_mutable_schemaname() {
  
  return schemaname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateSchemaStmt::release_schemaname() {
  // @@protoc_insertion_point(field_release:pg_query.CreateSchemaStmt.schemaname)
  return schemaname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateSchemaStmt::set_allocated_schemaname(std::string* schemaname) {
  if (schemaname != nullptr) {
    
  } else {
    
  }
  schemaname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), schemaname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateSchemaStmt.schemaname)
}

// .pg_query.RoleSpec authrole = 2 [json_name = "authrole"];
inline bool CreateSchemaStmt::_internal_has_authrole() const {
  return this != internal_default_instance() && authrole_ != nullptr;
}
inline bool CreateSchemaStmt::has_authrole() const {
  return _internal_has_authrole();
}
inline void CreateSchemaStmt::clear_authrole() {
  if (GetArena() == nullptr && authrole_ != nullptr) {
    delete authrole_;
  }
  authrole_ = nullptr;
}
inline const ::pg_query::RoleSpec& CreateSchemaStmt::_internal_authrole() const {
  const ::pg_query::RoleSpec* p = authrole_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(
      ::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& CreateSchemaStmt::authrole() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSchemaStmt.authrole)
  return _internal_authrole();
}
inline void CreateSchemaStmt::unsafe_arena_set_allocated_authrole(
    ::pg_query::RoleSpec* authrole) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(authrole_);
  }
  authrole_ = authrole;
  if (authrole) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateSchemaStmt.authrole)
}
inline ::pg_query::RoleSpec* CreateSchemaStmt::release_authrole() {
  
  ::pg_query::RoleSpec* temp = authrole_;
  authrole_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RoleSpec* CreateSchemaStmt::unsafe_arena_release_authrole() {
  // @@protoc_insertion_point(field_release:pg_query.CreateSchemaStmt.authrole)
  
  ::pg_query::RoleSpec* temp = authrole_;
  authrole_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* CreateSchemaStmt::_internal_mutable_authrole() {
  
  if (authrole_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    authrole_ = p;
  }
  return authrole_;
}
inline ::pg_query::RoleSpec* CreateSchemaStmt::mutable_authrole() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSchemaStmt.authrole)
  return _internal_mutable_authrole();
}
inline void CreateSchemaStmt::set_allocated_authrole(::pg_query::RoleSpec* authrole) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete authrole_;
  }
  if (authrole) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authrole);
    if (message_arena != submessage_arena) {
      authrole = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, authrole, submessage_arena);
    }
    
  } else {
    
  }
  authrole_ = authrole;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateSchemaStmt.authrole)
}

// repeated .pg_query.Node schema_elts = 3 [json_name = "schemaElts"];
inline int CreateSchemaStmt::_internal_schema_elts_size() const {
  return schema_elts_.size();
}
inline int CreateSchemaStmt::schema_elts_size() const {
  return _internal_schema_elts_size();
}
inline void CreateSchemaStmt::clear_schema_elts() {
  schema_elts_.Clear();
}
inline ::pg_query::Node* CreateSchemaStmt::mutable_schema_elts(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSchemaStmt.schema_elts)
  return schema_elts_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateSchemaStmt::mutable_schema_elts() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateSchemaStmt.schema_elts)
  return &schema_elts_;
}
inline const ::pg_query::Node& CreateSchemaStmt::_internal_schema_elts(int index) const {
  return schema_elts_.Get(index);
}
inline const ::pg_query::Node& CreateSchemaStmt::schema_elts(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSchemaStmt.schema_elts)
  return _internal_schema_elts(index);
}
inline ::pg_query::Node* CreateSchemaStmt::_internal_add_schema_elts() {
  return schema_elts_.Add();
}
inline ::pg_query::Node* CreateSchemaStmt::add_schema_elts() {
  // @@protoc_insertion_point(field_add:pg_query.CreateSchemaStmt.schema_elts)
  return _internal_add_schema_elts();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateSchemaStmt::schema_elts() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateSchemaStmt.schema_elts)
  return schema_elts_;
}

// bool if_not_exists = 4 [json_name = "if_not_exists"];
inline void CreateSchemaStmt::clear_if_not_exists() {
  if_not_exists_ = false;
}
inline bool CreateSchemaStmt::_internal_if_not_exists() const {
  return if_not_exists_;
}
inline bool CreateSchemaStmt::if_not_exists() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSchemaStmt.if_not_exists)
  return _internal_if_not_exists();
}
inline void CreateSchemaStmt::_internal_set_if_not_exists(bool value) {
  
  if_not_exists_ = value;
}
inline void CreateSchemaStmt::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateSchemaStmt.if_not_exists)
}

// -------------------------------------------------------------------

// AlterDatabaseStmt

// string dbname = 1 [json_name = "dbname"];
inline void AlterDatabaseStmt::clear_dbname() {
  dbname_.ClearToEmpty();
}
inline const std::string& AlterDatabaseStmt::dbname() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseStmt.dbname)
  return _internal_dbname();
}
inline void AlterDatabaseStmt::set_dbname(const std::string& value) {
  _internal_set_dbname(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterDatabaseStmt.dbname)
}
inline std::string* AlterDatabaseStmt::mutable_dbname() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDatabaseStmt.dbname)
  return _internal_mutable_dbname();
}
inline const std::string& AlterDatabaseStmt::_internal_dbname() const {
  return dbname_.Get();
}
inline void AlterDatabaseStmt::_internal_set_dbname(const std::string& value) {
  
  dbname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterDatabaseStmt::set_dbname(std::string&& value) {
  
  dbname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterDatabaseStmt.dbname)
}
inline void AlterDatabaseStmt::set_dbname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  dbname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterDatabaseStmt.dbname)
}
inline void AlterDatabaseStmt::set_dbname(const char* value,
    size_t size) {
  
  dbname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterDatabaseStmt.dbname)
}
inline std::string* AlterDatabaseStmt::_internal_mutable_dbname() {
  
  return dbname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterDatabaseStmt::release_dbname() {
  // @@protoc_insertion_point(field_release:pg_query.AlterDatabaseStmt.dbname)
  return dbname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterDatabaseStmt::set_allocated_dbname(std::string* dbname) {
  if (dbname != nullptr) {
    
  } else {
    
  }
  dbname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dbname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDatabaseStmt.dbname)
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int AlterDatabaseStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterDatabaseStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterDatabaseStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterDatabaseStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDatabaseStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterDatabaseStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterDatabaseStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterDatabaseStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterDatabaseStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterDatabaseStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterDatabaseStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterDatabaseStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterDatabaseStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterDatabaseStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// AlterDatabaseSetStmt

// string dbname = 1 [json_name = "dbname"];
inline void AlterDatabaseSetStmt::clear_dbname() {
  dbname_.ClearToEmpty();
}
inline const std::string& AlterDatabaseSetStmt::dbname() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseSetStmt.dbname)
  return _internal_dbname();
}
inline void AlterDatabaseSetStmt::set_dbname(const std::string& value) {
  _internal_set_dbname(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterDatabaseSetStmt.dbname)
}
inline std::string* AlterDatabaseSetStmt::mutable_dbname() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDatabaseSetStmt.dbname)
  return _internal_mutable_dbname();
}
inline const std::string& AlterDatabaseSetStmt::_internal_dbname() const {
  return dbname_.Get();
}
inline void AlterDatabaseSetStmt::_internal_set_dbname(const std::string& value) {
  
  dbname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterDatabaseSetStmt::set_dbname(std::string&& value) {
  
  dbname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterDatabaseSetStmt.dbname)
}
inline void AlterDatabaseSetStmt::set_dbname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  dbname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterDatabaseSetStmt.dbname)
}
inline void AlterDatabaseSetStmt::set_dbname(const char* value,
    size_t size) {
  
  dbname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterDatabaseSetStmt.dbname)
}
inline std::string* AlterDatabaseSetStmt::_internal_mutable_dbname() {
  
  return dbname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterDatabaseSetStmt::release_dbname() {
  // @@protoc_insertion_point(field_release:pg_query.AlterDatabaseSetStmt.dbname)
  return dbname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterDatabaseSetStmt::set_allocated_dbname(std::string* dbname) {
  if (dbname != nullptr) {
    
  } else {
    
  }
  dbname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dbname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDatabaseSetStmt.dbname)
}

// .pg_query.VariableSetStmt setstmt = 2 [json_name = "setstmt"];
inline bool AlterDatabaseSetStmt::_internal_has_setstmt() const {
  return this != internal_default_instance() && setstmt_ != nullptr;
}
inline bool AlterDatabaseSetStmt::has_setstmt() const {
  return _internal_has_setstmt();
}
inline void AlterDatabaseSetStmt::clear_setstmt() {
  if (GetArena() == nullptr && setstmt_ != nullptr) {
    delete setstmt_;
  }
  setstmt_ = nullptr;
}
inline const ::pg_query::VariableSetStmt& AlterDatabaseSetStmt::_internal_setstmt() const {
  const ::pg_query::VariableSetStmt* p = setstmt_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::VariableSetStmt&>(
      ::pg_query::_VariableSetStmt_default_instance_);
}
inline const ::pg_query::VariableSetStmt& AlterDatabaseSetStmt::setstmt() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseSetStmt.setstmt)
  return _internal_setstmt();
}
inline void AlterDatabaseSetStmt::unsafe_arena_set_allocated_setstmt(
    ::pg_query::VariableSetStmt* setstmt) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(setstmt_);
  }
  setstmt_ = setstmt;
  if (setstmt) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterDatabaseSetStmt.setstmt)
}
inline ::pg_query::VariableSetStmt* AlterDatabaseSetStmt::release_setstmt() {
  
  ::pg_query::VariableSetStmt* temp = setstmt_;
  setstmt_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::VariableSetStmt* AlterDatabaseSetStmt::unsafe_arena_release_setstmt() {
  // @@protoc_insertion_point(field_release:pg_query.AlterDatabaseSetStmt.setstmt)
  
  ::pg_query::VariableSetStmt* temp = setstmt_;
  setstmt_ = nullptr;
  return temp;
}
inline ::pg_query::VariableSetStmt* AlterDatabaseSetStmt::_internal_mutable_setstmt() {
  
  if (setstmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::VariableSetStmt>(GetArena());
    setstmt_ = p;
  }
  return setstmt_;
}
inline ::pg_query::VariableSetStmt* AlterDatabaseSetStmt::mutable_setstmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDatabaseSetStmt.setstmt)
  return _internal_mutable_setstmt();
}
inline void AlterDatabaseSetStmt::set_allocated_setstmt(::pg_query::VariableSetStmt* setstmt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete setstmt_;
  }
  if (setstmt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(setstmt);
    if (message_arena != submessage_arena) {
      setstmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, setstmt, submessage_arena);
    }
    
  } else {
    
  }
  setstmt_ = setstmt;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDatabaseSetStmt.setstmt)
}

// -------------------------------------------------------------------

// AlterRoleSetStmt

// .pg_query.RoleSpec role = 1 [json_name = "role"];
inline bool AlterRoleSetStmt::_internal_has_role() const {
  return this != internal_default_instance() && role_ != nullptr;
}
inline bool AlterRoleSetStmt::has_role() const {
  return _internal_has_role();
}
inline void AlterRoleSetStmt::clear_role() {
  if (GetArena() == nullptr && role_ != nullptr) {
    delete role_;
  }
  role_ = nullptr;
}
inline const ::pg_query::RoleSpec& AlterRoleSetStmt::_internal_role() const {
  const ::pg_query::RoleSpec* p = role_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(
      ::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& AlterRoleSetStmt::role() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterRoleSetStmt.role)
  return _internal_role();
}
inline void AlterRoleSetStmt::unsafe_arena_set_allocated_role(
    ::pg_query::RoleSpec* role) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(role_);
  }
  role_ = role;
  if (role) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterRoleSetStmt.role)
}
inline ::pg_query::RoleSpec* AlterRoleSetStmt::release_role() {
  
  ::pg_query::RoleSpec* temp = role_;
  role_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RoleSpec* AlterRoleSetStmt::unsafe_arena_release_role() {
  // @@protoc_insertion_point(field_release:pg_query.AlterRoleSetStmt.role)
  
  ::pg_query::RoleSpec* temp = role_;
  role_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* AlterRoleSetStmt::_internal_mutable_role() {
  
  if (role_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    role_ = p;
  }
  return role_;
}
inline ::pg_query::RoleSpec* AlterRoleSetStmt::mutable_role() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterRoleSetStmt.role)
  return _internal_mutable_role();
}
inline void AlterRoleSetStmt::set_allocated_role(::pg_query::RoleSpec* role) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete role_;
  }
  if (role) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(role);
    if (message_arena != submessage_arena) {
      role = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, role, submessage_arena);
    }
    
  } else {
    
  }
  role_ = role;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterRoleSetStmt.role)
}

// string database = 2 [json_name = "database"];
inline void AlterRoleSetStmt::clear_database() {
  database_.ClearToEmpty();
}
inline const std::string& AlterRoleSetStmt::database() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterRoleSetStmt.database)
  return _internal_database();
}
inline void AlterRoleSetStmt::set_database(const std::string& value) {
  _internal_set_database(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterRoleSetStmt.database)
}
inline std::string* AlterRoleSetStmt::mutable_database() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterRoleSetStmt.database)
  return _internal_mutable_database();
}
inline const std::string& AlterRoleSetStmt::_internal_database() const {
  return database_.Get();
}
inline void AlterRoleSetStmt::_internal_set_database(const std::string& value) {
  
  database_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterRoleSetStmt::set_database(std::string&& value) {
  
  database_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterRoleSetStmt.database)
}
inline void AlterRoleSetStmt::set_database(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  database_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterRoleSetStmt.database)
}
inline void AlterRoleSetStmt::set_database(const char* value,
    size_t size) {
  
  database_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterRoleSetStmt.database)
}
inline std::string* AlterRoleSetStmt::_internal_mutable_database() {
  
  return database_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterRoleSetStmt::release_database() {
  // @@protoc_insertion_point(field_release:pg_query.AlterRoleSetStmt.database)
  return database_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterRoleSetStmt::set_allocated_database(std::string* database) {
  if (database != nullptr) {
    
  } else {
    
  }
  database_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), database,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterRoleSetStmt.database)
}

// .pg_query.VariableSetStmt setstmt = 3 [json_name = "setstmt"];
inline bool AlterRoleSetStmt::_internal_has_setstmt() const {
  return this != internal_default_instance() && setstmt_ != nullptr;
}
inline bool AlterRoleSetStmt::has_setstmt() const {
  return _internal_has_setstmt();
}
inline void AlterRoleSetStmt::clear_setstmt() {
  if (GetArena() == nullptr && setstmt_ != nullptr) {
    delete setstmt_;
  }
  setstmt_ = nullptr;
}
inline const ::pg_query::VariableSetStmt& AlterRoleSetStmt::_internal_setstmt() const {
  const ::pg_query::VariableSetStmt* p = setstmt_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::VariableSetStmt&>(
      ::pg_query::_VariableSetStmt_default_instance_);
}
inline const ::pg_query::VariableSetStmt& AlterRoleSetStmt::setstmt() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterRoleSetStmt.setstmt)
  return _internal_setstmt();
}
inline void AlterRoleSetStmt::unsafe_arena_set_allocated_setstmt(
    ::pg_query::VariableSetStmt* setstmt) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(setstmt_);
  }
  setstmt_ = setstmt;
  if (setstmt) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterRoleSetStmt.setstmt)
}
inline ::pg_query::VariableSetStmt* AlterRoleSetStmt::release_setstmt() {
  
  ::pg_query::VariableSetStmt* temp = setstmt_;
  setstmt_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::VariableSetStmt* AlterRoleSetStmt::unsafe_arena_release_setstmt() {
  // @@protoc_insertion_point(field_release:pg_query.AlterRoleSetStmt.setstmt)
  
  ::pg_query::VariableSetStmt* temp = setstmt_;
  setstmt_ = nullptr;
  return temp;
}
inline ::pg_query::VariableSetStmt* AlterRoleSetStmt::_internal_mutable_setstmt() {
  
  if (setstmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::VariableSetStmt>(GetArena());
    setstmt_ = p;
  }
  return setstmt_;
}
inline ::pg_query::VariableSetStmt* AlterRoleSetStmt::mutable_setstmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterRoleSetStmt.setstmt)
  return _internal_mutable_setstmt();
}
inline void AlterRoleSetStmt::set_allocated_setstmt(::pg_query::VariableSetStmt* setstmt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete setstmt_;
  }
  if (setstmt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(setstmt);
    if (message_arena != submessage_arena) {
      setstmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, setstmt, submessage_arena);
    }
    
  } else {
    
  }
  setstmt_ = setstmt;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterRoleSetStmt.setstmt)
}

// -------------------------------------------------------------------

// CreateConversionStmt

// repeated .pg_query.Node conversion_name = 1 [json_name = "conversion_name"];
inline int CreateConversionStmt::_internal_conversion_name_size() const {
  return conversion_name_.size();
}
inline int CreateConversionStmt::conversion_name_size() const {
  return _internal_conversion_name_size();
}
inline void CreateConversionStmt::clear_conversion_name() {
  conversion_name_.Clear();
}
inline ::pg_query::Node* CreateConversionStmt::mutable_conversion_name(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateConversionStmt.conversion_name)
  return conversion_name_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateConversionStmt::mutable_conversion_name() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateConversionStmt.conversion_name)
  return &conversion_name_;
}
inline const ::pg_query::Node& CreateConversionStmt::_internal_conversion_name(int index) const {
  return conversion_name_.Get(index);
}
inline const ::pg_query::Node& CreateConversionStmt::conversion_name(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.conversion_name)
  return _internal_conversion_name(index);
}
inline ::pg_query::Node* CreateConversionStmt::_internal_add_conversion_name() {
  return conversion_name_.Add();
}
inline ::pg_query::Node* CreateConversionStmt::add_conversion_name() {
  // @@protoc_insertion_point(field_add:pg_query.CreateConversionStmt.conversion_name)
  return _internal_add_conversion_name();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateConversionStmt::conversion_name() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateConversionStmt.conversion_name)
  return conversion_name_;
}

// string for_encoding_name = 2 [json_name = "for_encoding_name"];
inline void CreateConversionStmt::clear_for_encoding_name() {
  for_encoding_name_.ClearToEmpty();
}
inline const std::string& CreateConversionStmt::for_encoding_name() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.for_encoding_name)
  return _internal_for_encoding_name();
}
inline void CreateConversionStmt::set_for_encoding_name(const std::string& value) {
  _internal_set_for_encoding_name(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateConversionStmt.for_encoding_name)
}
inline std::string* CreateConversionStmt::mutable_for_encoding_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateConversionStmt.for_encoding_name)
  return _internal_mutable_for_encoding_name();
}
inline const std::string& CreateConversionStmt::_internal_for_encoding_name() const {
  return for_encoding_name_.Get();
}
inline void CreateConversionStmt::_internal_set_for_encoding_name(const std::string& value) {
  
  for_encoding_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateConversionStmt::set_for_encoding_name(std::string&& value) {
  
  for_encoding_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateConversionStmt.for_encoding_name)
}
inline void CreateConversionStmt::set_for_encoding_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  for_encoding_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateConversionStmt.for_encoding_name)
}
inline void CreateConversionStmt::set_for_encoding_name(const char* value,
    size_t size) {
  
  for_encoding_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateConversionStmt.for_encoding_name)
}
inline std::string* CreateConversionStmt::_internal_mutable_for_encoding_name() {
  
  return for_encoding_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateConversionStmt::release_for_encoding_name() {
  // @@protoc_insertion_point(field_release:pg_query.CreateConversionStmt.for_encoding_name)
  return for_encoding_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateConversionStmt::set_allocated_for_encoding_name(std::string* for_encoding_name) {
  if (for_encoding_name != nullptr) {
    
  } else {
    
  }
  for_encoding_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), for_encoding_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateConversionStmt.for_encoding_name)
}

// string to_encoding_name = 3 [json_name = "to_encoding_name"];
inline void CreateConversionStmt::clear_to_encoding_name() {
  to_encoding_name_.ClearToEmpty();
}
inline const std::string& CreateConversionStmt::to_encoding_name() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.to_encoding_name)
  return _internal_to_encoding_name();
}
inline void CreateConversionStmt::set_to_encoding_name(const std::string& value) {
  _internal_set_to_encoding_name(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateConversionStmt.to_encoding_name)
}
inline std::string* CreateConversionStmt::mutable_to_encoding_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateConversionStmt.to_encoding_name)
  return _internal_mutable_to_encoding_name();
}
inline const std::string& CreateConversionStmt::_internal_to_encoding_name() const {
  return to_encoding_name_.Get();
}
inline void CreateConversionStmt::_internal_set_to_encoding_name(const std::string& value) {
  
  to_encoding_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateConversionStmt::set_to_encoding_name(std::string&& value) {
  
  to_encoding_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateConversionStmt.to_encoding_name)
}
inline void CreateConversionStmt::set_to_encoding_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  to_encoding_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateConversionStmt.to_encoding_name)
}
inline void CreateConversionStmt::set_to_encoding_name(const char* value,
    size_t size) {
  
  to_encoding_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateConversionStmt.to_encoding_name)
}
inline std::string* CreateConversionStmt::_internal_mutable_to_encoding_name() {
  
  return to_encoding_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateConversionStmt::release_to_encoding_name() {
  // @@protoc_insertion_point(field_release:pg_query.CreateConversionStmt.to_encoding_name)
  return to_encoding_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateConversionStmt::set_allocated_to_encoding_name(std::string* to_encoding_name) {
  if (to_encoding_name != nullptr) {
    
  } else {
    
  }
  to_encoding_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), to_encoding_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateConversionStmt.to_encoding_name)
}

// repeated .pg_query.Node func_name = 4 [json_name = "func_name"];
inline int CreateConversionStmt::_internal_func_name_size() const {
  return func_name_.size();
}
inline int CreateConversionStmt::func_name_size() const {
  return _internal_func_name_size();
}
inline void CreateConversionStmt::clear_func_name() {
  func_name_.Clear();
}
inline ::pg_query::Node* CreateConversionStmt::mutable_func_name(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateConversionStmt.func_name)
  return func_name_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateConversionStmt::mutable_func_name() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateConversionStmt.func_name)
  return &func_name_;
}
inline const ::pg_query::Node& CreateConversionStmt::_internal_func_name(int index) const {
  return func_name_.Get(index);
}
inline const ::pg_query::Node& CreateConversionStmt::func_name(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.func_name)
  return _internal_func_name(index);
}
inline ::pg_query::Node* CreateConversionStmt::_internal_add_func_name() {
  return func_name_.Add();
}
inline ::pg_query::Node* CreateConversionStmt::add_func_name() {
  // @@protoc_insertion_point(field_add:pg_query.CreateConversionStmt.func_name)
  return _internal_add_func_name();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateConversionStmt::func_name() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateConversionStmt.func_name)
  return func_name_;
}

// bool def = 5 [json_name = "def"];
inline void CreateConversionStmt::clear_def() {
  def_ = false;
}
inline bool CreateConversionStmt::_internal_def() const {
  return def_;
}
inline bool CreateConversionStmt::def() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.def)
  return _internal_def();
}
inline void CreateConversionStmt::_internal_set_def(bool value) {
  
  def_ = value;
}
inline void CreateConversionStmt::set_def(bool value) {
  _internal_set_def(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateConversionStmt.def)
}

// -------------------------------------------------------------------

// CreateCastStmt

// .pg_query.TypeName sourcetype = 1 [json_name = "sourcetype"];
inline bool CreateCastStmt::_internal_has_sourcetype() const {
  return this != internal_default_instance() && sourcetype_ != nullptr;
}
inline bool CreateCastStmt::has_sourcetype() const {
  return _internal_has_sourcetype();
}
inline void CreateCastStmt::clear_sourcetype() {
  if (GetArena() == nullptr && sourcetype_ != nullptr) {
    delete sourcetype_;
  }
  sourcetype_ = nullptr;
}
inline const ::pg_query::TypeName& CreateCastStmt::_internal_sourcetype() const {
  const ::pg_query::TypeName* p = sourcetype_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(
      ::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& CreateCastStmt::sourcetype() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.sourcetype)
  return _internal_sourcetype();
}
inline void CreateCastStmt::unsafe_arena_set_allocated_sourcetype(
    ::pg_query::TypeName* sourcetype) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sourcetype_);
  }
  sourcetype_ = sourcetype;
  if (sourcetype) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateCastStmt.sourcetype)
}
inline ::pg_query::TypeName* CreateCastStmt::release_sourcetype() {
  
  ::pg_query::TypeName* temp = sourcetype_;
  sourcetype_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TypeName* CreateCastStmt::unsafe_arena_release_sourcetype() {
  // @@protoc_insertion_point(field_release:pg_query.CreateCastStmt.sourcetype)
  
  ::pg_query::TypeName* temp = sourcetype_;
  sourcetype_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateCastStmt::_internal_mutable_sourcetype() {
  
  if (sourcetype_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    sourcetype_ = p;
  }
  return sourcetype_;
}
inline ::pg_query::TypeName* CreateCastStmt::mutable_sourcetype() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateCastStmt.sourcetype)
  return _internal_mutable_sourcetype();
}
inline void CreateCastStmt::set_allocated_sourcetype(::pg_query::TypeName* sourcetype) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete sourcetype_;
  }
  if (sourcetype) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sourcetype);
    if (message_arena != submessage_arena) {
      sourcetype = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sourcetype, submessage_arena);
    }
    
  } else {
    
  }
  sourcetype_ = sourcetype;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateCastStmt.sourcetype)
}

// .pg_query.TypeName targettype = 2 [json_name = "targettype"];
inline bool CreateCastStmt::_internal_has_targettype() const {
  return this != internal_default_instance() && targettype_ != nullptr;
}
inline bool CreateCastStmt::has_targettype() const {
  return _internal_has_targettype();
}
inline void CreateCastStmt::clear_targettype() {
  if (GetArena() == nullptr && targettype_ != nullptr) {
    delete targettype_;
  }
  targettype_ = nullptr;
}
inline const ::pg_query::TypeName& CreateCastStmt::_internal_targettype() const {
  const ::pg_query::TypeName* p = targettype_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(
      ::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& CreateCastStmt::targettype() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.targettype)
  return _internal_targettype();
}
inline void CreateCastStmt::unsafe_arena_set_allocated_targettype(
    ::pg_query::TypeName* targettype) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(targettype_);
  }
  targettype_ = targettype;
  if (targettype) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateCastStmt.targettype)
}
inline ::pg_query::TypeName* CreateCastStmt::release_targettype() {
  
  ::pg_query::TypeName* temp = targettype_;
  targettype_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TypeName* CreateCastStmt::unsafe_arena_release_targettype() {
  // @@protoc_insertion_point(field_release:pg_query.CreateCastStmt.targettype)
  
  ::pg_query::TypeName* temp = targettype_;
  targettype_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateCastStmt::_internal_mutable_targettype() {
  
  if (targettype_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    targettype_ = p;
  }
  return targettype_;
}
inline ::pg_query::TypeName* CreateCastStmt::mutable_targettype() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateCastStmt.targettype)
  return _internal_mutable_targettype();
}
inline void CreateCastStmt::set_allocated_targettype(::pg_query::TypeName* targettype) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete targettype_;
  }
  if (targettype) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(targettype);
    if (message_arena != submessage_arena) {
      targettype = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, targettype, submessage_arena);
    }
    
  } else {
    
  }
  targettype_ = targettype;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateCastStmt.targettype)
}

// .pg_query.ObjectWithArgs func = 3 [json_name = "func"];
inline bool CreateCastStmt::_internal_has_func() const {
  return this != internal_default_instance() && func_ != nullptr;
}
inline bool CreateCastStmt::has_func() const {
  return _internal_has_func();
}
inline void CreateCastStmt::clear_func() {
  if (GetArena() == nullptr && func_ != nullptr) {
    delete func_;
  }
  func_ = nullptr;
}
inline const ::pg_query::ObjectWithArgs& CreateCastStmt::_internal_func() const {
  const ::pg_query::ObjectWithArgs* p = func_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::ObjectWithArgs&>(
      ::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& CreateCastStmt::func() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.func)
  return _internal_func();
}
inline void CreateCastStmt::unsafe_arena_set_allocated_func(
    ::pg_query::ObjectWithArgs* func) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(func_);
  }
  func_ = func;
  if (func) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateCastStmt.func)
}
inline ::pg_query::ObjectWithArgs* CreateCastStmt::release_func() {
  
  ::pg_query::ObjectWithArgs* temp = func_;
  func_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::ObjectWithArgs* CreateCastStmt::unsafe_arena_release_func() {
  // @@protoc_insertion_point(field_release:pg_query.CreateCastStmt.func)
  
  ::pg_query::ObjectWithArgs* temp = func_;
  func_ = nullptr;
  return temp;
}
inline ::pg_query::ObjectWithArgs* CreateCastStmt::_internal_mutable_func() {
  
  if (func_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArena());
    func_ = p;
  }
  return func_;
}
inline ::pg_query::ObjectWithArgs* CreateCastStmt::mutable_func() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateCastStmt.func)
  return _internal_mutable_func();
}
inline void CreateCastStmt::set_allocated_func(::pg_query::ObjectWithArgs* func) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete func_;
  }
  if (func) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(func);
    if (message_arena != submessage_arena) {
      func = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, func, submessage_arena);
    }
    
  } else {
    
  }
  func_ = func;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateCastStmt.func)
}

// .pg_query.CoercionContext context = 4 [json_name = "context"];
inline void CreateCastStmt::clear_context() {
  context_ = 0;
}
inline ::pg_query::CoercionContext CreateCastStmt::_internal_context() const {
  return static_cast< ::pg_query::CoercionContext >(context_);
}
inline ::pg_query::CoercionContext CreateCastStmt::context() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.context)
  return _internal_context();
}
inline void CreateCastStmt::_internal_set_context(::pg_query::CoercionContext value) {
  
  context_ = value;
}
inline void CreateCastStmt::set_context(::pg_query::CoercionContext value) {
  _internal_set_context(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateCastStmt.context)
}

// bool inout = 5 [json_name = "inout"];
inline void CreateCastStmt::clear_inout() {
  inout_ = false;
}
inline bool CreateCastStmt::_internal_inout() const {
  return inout_;
}
inline bool CreateCastStmt::inout() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.inout)
  return _internal_inout();
}
inline void CreateCastStmt::_internal_set_inout(bool value) {
  
  inout_ = value;
}
inline void CreateCastStmt::set_inout(bool value) {
  _internal_set_inout(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateCastStmt.inout)
}

// -------------------------------------------------------------------

// CreateOpClassStmt

// repeated .pg_query.Node opclassname = 1 [json_name = "opclassname"];
inline int CreateOpClassStmt::_internal_opclassname_size() const {
  return opclassname_.size();
}
inline int CreateOpClassStmt::opclassname_size() const {
  return _internal_opclassname_size();
}
inline void CreateOpClassStmt::clear_opclassname() {
  opclassname_.Clear();
}
inline ::pg_query::Node* CreateOpClassStmt::mutable_opclassname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassStmt.opclassname)
  return opclassname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateOpClassStmt::mutable_opclassname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassStmt.opclassname)
  return &opclassname_;
}
inline const ::pg_query::Node& CreateOpClassStmt::_internal_opclassname(int index) const {
  return opclassname_.Get(index);
}
inline const ::pg_query::Node& CreateOpClassStmt::opclassname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.opclassname)
  return _internal_opclassname(index);
}
inline ::pg_query::Node* CreateOpClassStmt::_internal_add_opclassname() {
  return opclassname_.Add();
}
inline ::pg_query::Node* CreateOpClassStmt::add_opclassname() {
  // @@protoc_insertion_point(field_add:pg_query.CreateOpClassStmt.opclassname)
  return _internal_add_opclassname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateOpClassStmt::opclassname() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateOpClassStmt.opclassname)
  return opclassname_;
}

// repeated .pg_query.Node opfamilyname = 2 [json_name = "opfamilyname"];
inline int CreateOpClassStmt::_internal_opfamilyname_size() const {
  return opfamilyname_.size();
}
inline int CreateOpClassStmt::opfamilyname_size() const {
  return _internal_opfamilyname_size();
}
inline void CreateOpClassStmt::clear_opfamilyname() {
  opfamilyname_.Clear();
}
inline ::pg_query::Node* CreateOpClassStmt::mutable_opfamilyname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassStmt.opfamilyname)
  return opfamilyname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateOpClassStmt::mutable_opfamilyname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassStmt.opfamilyname)
  return &opfamilyname_;
}
inline const ::pg_query::Node& CreateOpClassStmt::_internal_opfamilyname(int index) const {
  return opfamilyname_.Get(index);
}
inline const ::pg_query::Node& CreateOpClassStmt::opfamilyname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.opfamilyname)
  return _internal_opfamilyname(index);
}
inline ::pg_query::Node* CreateOpClassStmt::_internal_add_opfamilyname() {
  return opfamilyname_.Add();
}
inline ::pg_query::Node* CreateOpClassStmt::add_opfamilyname() {
  // @@protoc_insertion_point(field_add:pg_query.CreateOpClassStmt.opfamilyname)
  return _internal_add_opfamilyname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateOpClassStmt::opfamilyname() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateOpClassStmt.opfamilyname)
  return opfamilyname_;
}

// string amname = 3 [json_name = "amname"];
inline void CreateOpClassStmt::clear_amname() {
  amname_.ClearToEmpty();
}
inline const std::string& CreateOpClassStmt::amname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.amname)
  return _internal_amname();
}
inline void CreateOpClassStmt::set_amname(const std::string& value) {
  _internal_set_amname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateOpClassStmt.amname)
}
inline std::string* CreateOpClassStmt::mutable_amname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassStmt.amname)
  return _internal_mutable_amname();
}
inline const std::string& CreateOpClassStmt::_internal_amname() const {
  return amname_.Get();
}
inline void CreateOpClassStmt::_internal_set_amname(const std::string& value) {
  
  amname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateOpClassStmt::set_amname(std::string&& value) {
  
  amname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateOpClassStmt.amname)
}
inline void CreateOpClassStmt::set_amname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  amname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateOpClassStmt.amname)
}
inline void CreateOpClassStmt::set_amname(const char* value,
    size_t size) {
  
  amname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateOpClassStmt.amname)
}
inline std::string* CreateOpClassStmt::_internal_mutable_amname() {
  
  return amname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateOpClassStmt::release_amname() {
  // @@protoc_insertion_point(field_release:pg_query.CreateOpClassStmt.amname)
  return amname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateOpClassStmt::set_allocated_amname(std::string* amname) {
  if (amname != nullptr) {
    
  } else {
    
  }
  amname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), amname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateOpClassStmt.amname)
}

// .pg_query.TypeName datatype = 4 [json_name = "datatype"];
inline bool CreateOpClassStmt::_internal_has_datatype() const {
  return this != internal_default_instance() && datatype_ != nullptr;
}
inline bool CreateOpClassStmt::has_datatype() const {
  return _internal_has_datatype();
}
inline void CreateOpClassStmt::clear_datatype() {
  if (GetArena() == nullptr && datatype_ != nullptr) {
    delete datatype_;
  }
  datatype_ = nullptr;
}
inline const ::pg_query::TypeName& CreateOpClassStmt::_internal_datatype() const {
  const ::pg_query::TypeName* p = datatype_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(
      ::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& CreateOpClassStmt::datatype() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.datatype)
  return _internal_datatype();
}
inline void CreateOpClassStmt::unsafe_arena_set_allocated_datatype(
    ::pg_query::TypeName* datatype) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(datatype_);
  }
  datatype_ = datatype;
  if (datatype) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateOpClassStmt.datatype)
}
inline ::pg_query::TypeName* CreateOpClassStmt::release_datatype() {
  
  ::pg_query::TypeName* temp = datatype_;
  datatype_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TypeName* CreateOpClassStmt::unsafe_arena_release_datatype() {
  // @@protoc_insertion_point(field_release:pg_query.CreateOpClassStmt.datatype)
  
  ::pg_query::TypeName* temp = datatype_;
  datatype_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateOpClassStmt::_internal_mutable_datatype() {
  
  if (datatype_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    datatype_ = p;
  }
  return datatype_;
}
inline ::pg_query::TypeName* CreateOpClassStmt::mutable_datatype() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassStmt.datatype)
  return _internal_mutable_datatype();
}
inline void CreateOpClassStmt::set_allocated_datatype(::pg_query::TypeName* datatype) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete datatype_;
  }
  if (datatype) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(datatype);
    if (message_arena != submessage_arena) {
      datatype = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, datatype, submessage_arena);
    }
    
  } else {
    
  }
  datatype_ = datatype;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateOpClassStmt.datatype)
}

// repeated .pg_query.Node items = 5 [json_name = "items"];
inline int CreateOpClassStmt::_internal_items_size() const {
  return items_.size();
}
inline int CreateOpClassStmt::items_size() const {
  return _internal_items_size();
}
inline void CreateOpClassStmt::clear_items() {
  items_.Clear();
}
inline ::pg_query::Node* CreateOpClassStmt::mutable_items(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassStmt.items)
  return items_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateOpClassStmt::mutable_items() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassStmt.items)
  return &items_;
}
inline const ::pg_query::Node& CreateOpClassStmt::_internal_items(int index) const {
  return items_.Get(index);
}
inline const ::pg_query::Node& CreateOpClassStmt::items(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.items)
  return _internal_items(index);
}
inline ::pg_query::Node* CreateOpClassStmt::_internal_add_items() {
  return items_.Add();
}
inline ::pg_query::Node* CreateOpClassStmt::add_items() {
  // @@protoc_insertion_point(field_add:pg_query.CreateOpClassStmt.items)
  return _internal_add_items();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateOpClassStmt::items() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateOpClassStmt.items)
  return items_;
}

// bool is_default = 6 [json_name = "isDefault"];
inline void CreateOpClassStmt::clear_is_default() {
  is_default_ = false;
}
inline bool CreateOpClassStmt::_internal_is_default() const {
  return is_default_;
}
inline bool CreateOpClassStmt::is_default() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.is_default)
  return _internal_is_default();
}
inline void CreateOpClassStmt::_internal_set_is_default(bool value) {
  
  is_default_ = value;
}
inline void CreateOpClassStmt::set_is_default(bool value) {
  _internal_set_is_default(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateOpClassStmt.is_default)
}

// -------------------------------------------------------------------

// CreateOpFamilyStmt

// repeated .pg_query.Node opfamilyname = 1 [json_name = "opfamilyname"];
inline int CreateOpFamilyStmt::_internal_opfamilyname_size() const {
  return opfamilyname_.size();
}
inline int CreateOpFamilyStmt::opfamilyname_size() const {
  return _internal_opfamilyname_size();
}
inline void CreateOpFamilyStmt::clear_opfamilyname() {
  opfamilyname_.Clear();
}
inline ::pg_query::Node* CreateOpFamilyStmt::mutable_opfamilyname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpFamilyStmt.opfamilyname)
  return opfamilyname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateOpFamilyStmt::mutable_opfamilyname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpFamilyStmt.opfamilyname)
  return &opfamilyname_;
}
inline const ::pg_query::Node& CreateOpFamilyStmt::_internal_opfamilyname(int index) const {
  return opfamilyname_.Get(index);
}
inline const ::pg_query::Node& CreateOpFamilyStmt::opfamilyname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpFamilyStmt.opfamilyname)
  return _internal_opfamilyname(index);
}
inline ::pg_query::Node* CreateOpFamilyStmt::_internal_add_opfamilyname() {
  return opfamilyname_.Add();
}
inline ::pg_query::Node* CreateOpFamilyStmt::add_opfamilyname() {
  // @@protoc_insertion_point(field_add:pg_query.CreateOpFamilyStmt.opfamilyname)
  return _internal_add_opfamilyname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateOpFamilyStmt::opfamilyname() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateOpFamilyStmt.opfamilyname)
  return opfamilyname_;
}

// string amname = 2 [json_name = "amname"];
inline void CreateOpFamilyStmt::clear_amname() {
  amname_.ClearToEmpty();
}
inline const std::string& CreateOpFamilyStmt::amname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpFamilyStmt.amname)
  return _internal_amname();
}
inline void CreateOpFamilyStmt::set_amname(const std::string& value) {
  _internal_set_amname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateOpFamilyStmt.amname)
}
inline std::string* CreateOpFamilyStmt::mutable_amname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpFamilyStmt.amname)
  return _internal_mutable_amname();
}
inline const std::string& CreateOpFamilyStmt::_internal_amname() const {
  return amname_.Get();
}
inline void CreateOpFamilyStmt::_internal_set_amname(const std::string& value) {
  
  amname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateOpFamilyStmt::set_amname(std::string&& value) {
  
  amname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateOpFamilyStmt.amname)
}
inline void CreateOpFamilyStmt::set_amname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  amname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateOpFamilyStmt.amname)
}
inline void CreateOpFamilyStmt::set_amname(const char* value,
    size_t size) {
  
  amname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateOpFamilyStmt.amname)
}
inline std::string* CreateOpFamilyStmt::_internal_mutable_amname() {
  
  return amname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateOpFamilyStmt::release_amname() {
  // @@protoc_insertion_point(field_release:pg_query.CreateOpFamilyStmt.amname)
  return amname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateOpFamilyStmt::set_allocated_amname(std::string* amname) {
  if (amname != nullptr) {
    
  } else {
    
  }
  amname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), amname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateOpFamilyStmt.amname)
}

// -------------------------------------------------------------------

// AlterOpFamilyStmt

// repeated .pg_query.Node opfamilyname = 1 [json_name = "opfamilyname"];
inline int AlterOpFamilyStmt::_internal_opfamilyname_size() const {
  return opfamilyname_.size();
}
inline int AlterOpFamilyStmt::opfamilyname_size() const {
  return _internal_opfamilyname_size();
}
inline void AlterOpFamilyStmt::clear_opfamilyname() {
  opfamilyname_.Clear();
}
inline ::pg_query::Node* AlterOpFamilyStmt::mutable_opfamilyname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOpFamilyStmt.opfamilyname)
  return opfamilyname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterOpFamilyStmt::mutable_opfamilyname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterOpFamilyStmt.opfamilyname)
  return &opfamilyname_;
}
inline const ::pg_query::Node& AlterOpFamilyStmt::_internal_opfamilyname(int index) const {
  return opfamilyname_.Get(index);
}
inline const ::pg_query::Node& AlterOpFamilyStmt::opfamilyname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterOpFamilyStmt.opfamilyname)
  return _internal_opfamilyname(index);
}
inline ::pg_query::Node* AlterOpFamilyStmt::_internal_add_opfamilyname() {
  return opfamilyname_.Add();
}
inline ::pg_query::Node* AlterOpFamilyStmt::add_opfamilyname() {
  // @@protoc_insertion_point(field_add:pg_query.AlterOpFamilyStmt.opfamilyname)
  return _internal_add_opfamilyname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterOpFamilyStmt::opfamilyname() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterOpFamilyStmt.opfamilyname)
  return opfamilyname_;
}

// string amname = 2 [json_name = "amname"];
inline void AlterOpFamilyStmt::clear_amname() {
  amname_.ClearToEmpty();
}
inline const std::string& AlterOpFamilyStmt::amname() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterOpFamilyStmt.amname)
  return _internal_amname();
}
inline void AlterOpFamilyStmt::set_amname(const std::string& value) {
  _internal_set_amname(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterOpFamilyStmt.amname)
}
inline std::string* AlterOpFamilyStmt::mutable_amname() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOpFamilyStmt.amname)
  return _internal_mutable_amname();
}
inline const std::string& AlterOpFamilyStmt::_internal_amname() const {
  return amname_.Get();
}
inline void AlterOpFamilyStmt::_internal_set_amname(const std::string& value) {
  
  amname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterOpFamilyStmt::set_amname(std::string&& value) {
  
  amname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterOpFamilyStmt.amname)
}
inline void AlterOpFamilyStmt::set_amname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  amname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterOpFamilyStmt.amname)
}
inline void AlterOpFamilyStmt::set_amname(const char* value,
    size_t size) {
  
  amname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterOpFamilyStmt.amname)
}
inline std::string* AlterOpFamilyStmt::_internal_mutable_amname() {
  
  return amname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterOpFamilyStmt::release_amname() {
  // @@protoc_insertion_point(field_release:pg_query.AlterOpFamilyStmt.amname)
  return amname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterOpFamilyStmt::set_allocated_amname(std::string* amname) {
  if (amname != nullptr) {
    
  } else {
    
  }
  amname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), amname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterOpFamilyStmt.amname)
}

// bool is_drop = 3 [json_name = "isDrop"];
inline void AlterOpFamilyStmt::clear_is_drop() {
  is_drop_ = false;
}
inline bool AlterOpFamilyStmt::_internal_is_drop() const {
  return is_drop_;
}
inline bool AlterOpFamilyStmt::is_drop() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterOpFamilyStmt.is_drop)
  return _internal_is_drop();
}
inline void AlterOpFamilyStmt::_internal_set_is_drop(bool value) {
  
  is_drop_ = value;
}
inline void AlterOpFamilyStmt::set_is_drop(bool value) {
  _internal_set_is_drop(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterOpFamilyStmt.is_drop)
}

// repeated .pg_query.Node items = 4 [json_name = "items"];
inline int AlterOpFamilyStmt::_internal_items_size() const {
  return items_.size();
}
inline int AlterOpFamilyStmt::items_size() const {
  return _internal_items_size();
}
inline void AlterOpFamilyStmt::clear_items() {
  items_.Clear();
}
inline ::pg_query::Node* AlterOpFamilyStmt::mutable_items(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOpFamilyStmt.items)
  return items_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterOpFamilyStmt::mutable_items() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterOpFamilyStmt.items)
  return &items_;
}
inline const ::pg_query::Node& AlterOpFamilyStmt::_internal_items(int index) const {
  return items_.Get(index);
}
inline const ::pg_query::Node& AlterOpFamilyStmt::items(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterOpFamilyStmt.items)
  return _internal_items(index);
}
inline ::pg_query::Node* AlterOpFamilyStmt::_internal_add_items() {
  return items_.Add();
}
inline ::pg_query::Node* AlterOpFamilyStmt::add_items() {
  // @@protoc_insertion_point(field_add:pg_query.AlterOpFamilyStmt.items)
  return _internal_add_items();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterOpFamilyStmt::items() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterOpFamilyStmt.items)
  return items_;
}

// -------------------------------------------------------------------

// PrepareStmt

// string name = 1 [json_name = "name"];
inline void PrepareStmt::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& PrepareStmt::name() const {
  // @@protoc_insertion_point(field_get:pg_query.PrepareStmt.name)
  return _internal_name();
}
inline void PrepareStmt::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.PrepareStmt.name)
}
inline std::string* PrepareStmt::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.PrepareStmt.name)
  return _internal_mutable_name();
}
inline const std::string& PrepareStmt::_internal_name() const {
  return name_.Get();
}
inline void PrepareStmt::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void PrepareStmt::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.PrepareStmt.name)
}
inline void PrepareStmt::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.PrepareStmt.name)
}
inline void PrepareStmt::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.PrepareStmt.name)
}
inline std::string* PrepareStmt::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* PrepareStmt::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.PrepareStmt.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void PrepareStmt::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.PrepareStmt.name)
}

// repeated .pg_query.Node argtypes = 2 [json_name = "argtypes"];
inline int PrepareStmt::_internal_argtypes_size() const {
  return argtypes_.size();
}
inline int PrepareStmt::argtypes_size() const {
  return _internal_argtypes_size();
}
inline void PrepareStmt::clear_argtypes() {
  argtypes_.Clear();
}
inline ::pg_query::Node* PrepareStmt::mutable_argtypes(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.PrepareStmt.argtypes)
  return argtypes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
PrepareStmt::mutable_argtypes() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PrepareStmt.argtypes)
  return &argtypes_;
}
inline const ::pg_query::Node& PrepareStmt::_internal_argtypes(int index) const {
  return argtypes_.Get(index);
}
inline const ::pg_query::Node& PrepareStmt::argtypes(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.PrepareStmt.argtypes)
  return _internal_argtypes(index);
}
inline ::pg_query::Node* PrepareStmt::_internal_add_argtypes() {
  return argtypes_.Add();
}
inline ::pg_query::Node* PrepareStmt::add_argtypes() {
  // @@protoc_insertion_point(field_add:pg_query.PrepareStmt.argtypes)
  return _internal_add_argtypes();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
PrepareStmt::argtypes() const {
  // @@protoc_insertion_point(field_list:pg_query.PrepareStmt.argtypes)
  return argtypes_;
}

// .pg_query.Node query = 3 [json_name = "query"];
inline bool PrepareStmt::_internal_has_query() const {
  return this != internal_default_instance() && query_ != nullptr;
}
inline bool PrepareStmt::has_query() const {
  return _internal_has_query();
}
inline void PrepareStmt::clear_query() {
  if (GetArena() == nullptr && query_ != nullptr) {
    delete query_;
  }
  query_ = nullptr;
}
inline const ::pg_query::Node& PrepareStmt::_internal_query() const {
  const ::pg_query::Node* p = query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& PrepareStmt::query() const {
  // @@protoc_insertion_point(field_get:pg_query.PrepareStmt.query)
  return _internal_query();
}
inline void PrepareStmt::unsafe_arena_set_allocated_query(
    ::pg_query::Node* query) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(query_);
  }
  query_ = query;
  if (query) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PrepareStmt.query)
}
inline ::pg_query::Node* PrepareStmt::release_query() {
  
  ::pg_query::Node* temp = query_;
  query_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* PrepareStmt::unsafe_arena_release_query() {
  // @@protoc_insertion_point(field_release:pg_query.PrepareStmt.query)
  
  ::pg_query::Node* temp = query_;
  query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* PrepareStmt::_internal_mutable_query() {
  
  if (query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    query_ = p;
  }
  return query_;
}
inline ::pg_query::Node* PrepareStmt::mutable_query() {
  // @@protoc_insertion_point(field_mutable:pg_query.PrepareStmt.query)
  return _internal_mutable_query();
}
inline void PrepareStmt::set_allocated_query(::pg_query::Node* query) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete query_;
  }
  if (query) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(query);
    if (message_arena != submessage_arena) {
      query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, query, submessage_arena);
    }
    
  } else {
    
  }
  query_ = query;
  // @@protoc_insertion_point(field_set_allocated:pg_query.PrepareStmt.query)
}

// -------------------------------------------------------------------

// ExecuteStmt

// string name = 1 [json_name = "name"];
inline void ExecuteStmt::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& ExecuteStmt::name() const {
  // @@protoc_insertion_point(field_get:pg_query.ExecuteStmt.name)
  return _internal_name();
}
inline void ExecuteStmt::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.ExecuteStmt.name)
}
inline std::string* ExecuteStmt::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.ExecuteStmt.name)
  return _internal_mutable_name();
}
inline const std::string& ExecuteStmt::_internal_name() const {
  return name_.Get();
}
inline void ExecuteStmt::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ExecuteStmt::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ExecuteStmt.name)
}
inline void ExecuteStmt::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ExecuteStmt.name)
}
inline void ExecuteStmt::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ExecuteStmt.name)
}
inline std::string* ExecuteStmt::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ExecuteStmt::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.ExecuteStmt.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ExecuteStmt::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ExecuteStmt.name)
}

// repeated .pg_query.Node params = 2 [json_name = "params"];
inline int ExecuteStmt::_internal_params_size() const {
  return params_.size();
}
inline int ExecuteStmt::params_size() const {
  return _internal_params_size();
}
inline void ExecuteStmt::clear_params() {
  params_.Clear();
}
inline ::pg_query::Node* ExecuteStmt::mutable_params(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ExecuteStmt.params)
  return params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ExecuteStmt::mutable_params() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ExecuteStmt.params)
  return &params_;
}
inline const ::pg_query::Node& ExecuteStmt::_internal_params(int index) const {
  return params_.Get(index);
}
inline const ::pg_query::Node& ExecuteStmt::params(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ExecuteStmt.params)
  return _internal_params(index);
}
inline ::pg_query::Node* ExecuteStmt::_internal_add_params() {
  return params_.Add();
}
inline ::pg_query::Node* ExecuteStmt::add_params() {
  // @@protoc_insertion_point(field_add:pg_query.ExecuteStmt.params)
  return _internal_add_params();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ExecuteStmt::params() const {
  // @@protoc_insertion_point(field_list:pg_query.ExecuteStmt.params)
  return params_;
}

// -------------------------------------------------------------------

// DeallocateStmt

// string name = 1 [json_name = "name"];
inline void DeallocateStmt::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& DeallocateStmt::name() const {
  // @@protoc_insertion_point(field_get:pg_query.DeallocateStmt.name)
  return _internal_name();
}
inline void DeallocateStmt::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.DeallocateStmt.name)
}
inline std::string* DeallocateStmt::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.DeallocateStmt.name)
  return _internal_mutable_name();
}
inline const std::string& DeallocateStmt::_internal_name() const {
  return name_.Get();
}
inline void DeallocateStmt::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void DeallocateStmt::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.DeallocateStmt.name)
}
inline void DeallocateStmt::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.DeallocateStmt.name)
}
inline void DeallocateStmt::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.DeallocateStmt.name)
}
inline std::string* DeallocateStmt::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* DeallocateStmt::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.DeallocateStmt.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void DeallocateStmt::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.DeallocateStmt.name)
}

// -------------------------------------------------------------------

// DeclareCursorStmt

// string portalname = 1 [json_name = "portalname"];
inline void DeclareCursorStmt::clear_portalname() {
  portalname_.ClearToEmpty();
}
inline const std::string& DeclareCursorStmt::portalname() const {
  // @@protoc_insertion_point(field_get:pg_query.DeclareCursorStmt.portalname)
  return _internal_portalname();
}
inline void DeclareCursorStmt::set_portalname(const std::string& value) {
  _internal_set_portalname(value);
  // @@protoc_insertion_point(field_set:pg_query.DeclareCursorStmt.portalname)
}
inline std::string* DeclareCursorStmt::mutable_portalname() {
  // @@protoc_insertion_point(field_mutable:pg_query.DeclareCursorStmt.portalname)
  return _internal_mutable_portalname();
}
inline const std::string& DeclareCursorStmt::_internal_portalname() const {
  return portalname_.Get();
}
inline void DeclareCursorStmt::_internal_set_portalname(const std::string& value) {
  
  portalname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void DeclareCursorStmt::set_portalname(std::string&& value) {
  
  portalname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.DeclareCursorStmt.portalname)
}
inline void DeclareCursorStmt::set_portalname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  portalname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.DeclareCursorStmt.portalname)
}
inline void DeclareCursorStmt::set_portalname(const char* value,
    size_t size) {
  
  portalname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.DeclareCursorStmt.portalname)
}
inline std::string* DeclareCursorStmt::_internal_mutable_portalname() {
  
  return portalname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* DeclareCursorStmt::release_portalname() {
  // @@protoc_insertion_point(field_release:pg_query.DeclareCursorStmt.portalname)
  return portalname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void DeclareCursorStmt::set_allocated_portalname(std::string* portalname) {
  if (portalname != nullptr) {
    
  } else {
    
  }
  portalname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), portalname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.DeclareCursorStmt.portalname)
}

// int32 options = 2 [json_name = "options"];
inline void DeclareCursorStmt::clear_options() {
  options_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeclareCursorStmt::_internal_options() const {
  return options_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeclareCursorStmt::options() const {
  // @@protoc_insertion_point(field_get:pg_query.DeclareCursorStmt.options)
  return _internal_options();
}
inline void DeclareCursorStmt::_internal_set_options(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  options_ = value;
}
inline void DeclareCursorStmt::set_options(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_options(value);
  // @@protoc_insertion_point(field_set:pg_query.DeclareCursorStmt.options)
}

// .pg_query.Node query = 3 [json_name = "query"];
inline bool DeclareCursorStmt::_internal_has_query() const {
  return this != internal_default_instance() && query_ != nullptr;
}
inline bool DeclareCursorStmt::has_query() const {
  return _internal_has_query();
}
inline void DeclareCursorStmt::clear_query() {
  if (GetArena() == nullptr && query_ != nullptr) {
    delete query_;
  }
  query_ = nullptr;
}
inline const ::pg_query::Node& DeclareCursorStmt::_internal_query() const {
  const ::pg_query::Node* p = query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& DeclareCursorStmt::query() const {
  // @@protoc_insertion_point(field_get:pg_query.DeclareCursorStmt.query)
  return _internal_query();
}
inline void DeclareCursorStmt::unsafe_arena_set_allocated_query(
    ::pg_query::Node* query) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(query_);
  }
  query_ = query;
  if (query) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DeclareCursorStmt.query)
}
inline ::pg_query::Node* DeclareCursorStmt::release_query() {
  
  ::pg_query::Node* temp = query_;
  query_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* DeclareCursorStmt::unsafe_arena_release_query() {
  // @@protoc_insertion_point(field_release:pg_query.DeclareCursorStmt.query)
  
  ::pg_query::Node* temp = query_;
  query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* DeclareCursorStmt::_internal_mutable_query() {
  
  if (query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    query_ = p;
  }
  return query_;
}
inline ::pg_query::Node* DeclareCursorStmt::mutable_query() {
  // @@protoc_insertion_point(field_mutable:pg_query.DeclareCursorStmt.query)
  return _internal_mutable_query();
}
inline void DeclareCursorStmt::set_allocated_query(::pg_query::Node* query) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete query_;
  }
  if (query) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(query);
    if (message_arena != submessage_arena) {
      query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, query, submessage_arena);
    }
    
  } else {
    
  }
  query_ = query;
  // @@protoc_insertion_point(field_set_allocated:pg_query.DeclareCursorStmt.query)
}

// -------------------------------------------------------------------

// CreateTableSpaceStmt

// string tablespacename = 1 [json_name = "tablespacename"];
inline void CreateTableSpaceStmt::clear_tablespacename() {
  tablespacename_.ClearToEmpty();
}
inline const std::string& CreateTableSpaceStmt::tablespacename() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableSpaceStmt.tablespacename)
  return _internal_tablespacename();
}
inline void CreateTableSpaceStmt::set_tablespacename(const std::string& value) {
  _internal_set_tablespacename(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTableSpaceStmt.tablespacename)
}
inline std::string* CreateTableSpaceStmt::mutable_tablespacename() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTableSpaceStmt.tablespacename)
  return _internal_mutable_tablespacename();
}
inline const std::string& CreateTableSpaceStmt::_internal_tablespacename() const {
  return tablespacename_.Get();
}
inline void CreateTableSpaceStmt::_internal_set_tablespacename(const std::string& value) {
  
  tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateTableSpaceStmt::set_tablespacename(std::string&& value) {
  
  tablespacename_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateTableSpaceStmt.tablespacename)
}
inline void CreateTableSpaceStmt::set_tablespacename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateTableSpaceStmt.tablespacename)
}
inline void CreateTableSpaceStmt::set_tablespacename(const char* value,
    size_t size) {
  
  tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateTableSpaceStmt.tablespacename)
}
inline std::string* CreateTableSpaceStmt::_internal_mutable_tablespacename() {
  
  return tablespacename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateTableSpaceStmt::release_tablespacename() {
  // @@protoc_insertion_point(field_release:pg_query.CreateTableSpaceStmt.tablespacename)
  return tablespacename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateTableSpaceStmt::set_allocated_tablespacename(std::string* tablespacename) {
  if (tablespacename != nullptr) {
    
  } else {
    
  }
  tablespacename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tablespacename,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTableSpaceStmt.tablespacename)
}

// .pg_query.RoleSpec owner = 2 [json_name = "owner"];
inline bool CreateTableSpaceStmt::_internal_has_owner() const {
  return this != internal_default_instance() && owner_ != nullptr;
}
inline bool CreateTableSpaceStmt::has_owner() const {
  return _internal_has_owner();
}
inline void CreateTableSpaceStmt::clear_owner() {
  if (GetArena() == nullptr && owner_ != nullptr) {
    delete owner_;
  }
  owner_ = nullptr;
}
inline const ::pg_query::RoleSpec& CreateTableSpaceStmt::_internal_owner() const {
  const ::pg_query::RoleSpec* p = owner_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(
      ::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& CreateTableSpaceStmt::owner() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableSpaceStmt.owner)
  return _internal_owner();
}
inline void CreateTableSpaceStmt::unsafe_arena_set_allocated_owner(
    ::pg_query::RoleSpec* owner) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(owner_);
  }
  owner_ = owner;
  if (owner) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTableSpaceStmt.owner)
}
inline ::pg_query::RoleSpec* CreateTableSpaceStmt::release_owner() {
  
  ::pg_query::RoleSpec* temp = owner_;
  owner_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RoleSpec* CreateTableSpaceStmt::unsafe_arena_release_owner() {
  // @@protoc_insertion_point(field_release:pg_query.CreateTableSpaceStmt.owner)
  
  ::pg_query::RoleSpec* temp = owner_;
  owner_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* CreateTableSpaceStmt::_internal_mutable_owner() {
  
  if (owner_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    owner_ = p;
  }
  return owner_;
}
inline ::pg_query::RoleSpec* CreateTableSpaceStmt::mutable_owner() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTableSpaceStmt.owner)
  return _internal_mutable_owner();
}
inline void CreateTableSpaceStmt::set_allocated_owner(::pg_query::RoleSpec* owner) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete owner_;
  }
  if (owner) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(owner);
    if (message_arena != submessage_arena) {
      owner = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, owner, submessage_arena);
    }
    
  } else {
    
  }
  owner_ = owner;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTableSpaceStmt.owner)
}

// string location = 3 [json_name = "location"];
inline void CreateTableSpaceStmt::clear_location() {
  location_.ClearToEmpty();
}
inline const std::string& CreateTableSpaceStmt::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableSpaceStmt.location)
  return _internal_location();
}
inline void CreateTableSpaceStmt::set_location(const std::string& value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTableSpaceStmt.location)
}
inline std::string* CreateTableSpaceStmt::mutable_location() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTableSpaceStmt.location)
  return _internal_mutable_location();
}
inline const std::string& CreateTableSpaceStmt::_internal_location() const {
  return location_.Get();
}
inline void CreateTableSpaceStmt::_internal_set_location(const std::string& value) {
  
  location_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateTableSpaceStmt::set_location(std::string&& value) {
  
  location_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateTableSpaceStmt.location)
}
inline void CreateTableSpaceStmt::set_location(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  location_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateTableSpaceStmt.location)
}
inline void CreateTableSpaceStmt::set_location(const char* value,
    size_t size) {
  
  location_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateTableSpaceStmt.location)
}
inline std::string* CreateTableSpaceStmt::_internal_mutable_location() {
  
  return location_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateTableSpaceStmt::release_location() {
  // @@protoc_insertion_point(field_release:pg_query.CreateTableSpaceStmt.location)
  return location_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateTableSpaceStmt::set_allocated_location(std::string* location) {
  if (location != nullptr) {
    
  } else {
    
  }
  location_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), location,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTableSpaceStmt.location)
}

// repeated .pg_query.Node options = 4 [json_name = "options"];
inline int CreateTableSpaceStmt::_internal_options_size() const {
  return options_.size();
}
inline int CreateTableSpaceStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateTableSpaceStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CreateTableSpaceStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTableSpaceStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateTableSpaceStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTableSpaceStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CreateTableSpaceStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CreateTableSpaceStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableSpaceStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CreateTableSpaceStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CreateTableSpaceStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreateTableSpaceStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateTableSpaceStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateTableSpaceStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// DropTableSpaceStmt

// string tablespacename = 1 [json_name = "tablespacename"];
inline void DropTableSpaceStmt::clear_tablespacename() {
  tablespacename_.ClearToEmpty();
}
inline const std::string& DropTableSpaceStmt::tablespacename() const {
  // @@protoc_insertion_point(field_get:pg_query.DropTableSpaceStmt.tablespacename)
  return _internal_tablespacename();
}
inline void DropTableSpaceStmt::set_tablespacename(const std::string& value) {
  _internal_set_tablespacename(value);
  // @@protoc_insertion_point(field_set:pg_query.DropTableSpaceStmt.tablespacename)
}
inline std::string* DropTableSpaceStmt::mutable_tablespacename() {
  // @@protoc_insertion_point(field_mutable:pg_query.DropTableSpaceStmt.tablespacename)
  return _internal_mutable_tablespacename();
}
inline const std::string& DropTableSpaceStmt::_internal_tablespacename() const {
  return tablespacename_.Get();
}
inline void DropTableSpaceStmt::_internal_set_tablespacename(const std::string& value) {
  
  tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void DropTableSpaceStmt::set_tablespacename(std::string&& value) {
  
  tablespacename_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.DropTableSpaceStmt.tablespacename)
}
inline void DropTableSpaceStmt::set_tablespacename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.DropTableSpaceStmt.tablespacename)
}
inline void DropTableSpaceStmt::set_tablespacename(const char* value,
    size_t size) {
  
  tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.DropTableSpaceStmt.tablespacename)
}
inline std::string* DropTableSpaceStmt::_internal_mutable_tablespacename() {
  
  return tablespacename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* DropTableSpaceStmt::release_tablespacename() {
  // @@protoc_insertion_point(field_release:pg_query.DropTableSpaceStmt.tablespacename)
  return tablespacename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void DropTableSpaceStmt::set_allocated_tablespacename(std::string* tablespacename) {
  if (tablespacename != nullptr) {
    
  } else {
    
  }
  tablespacename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tablespacename,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.DropTableSpaceStmt.tablespacename)
}

// bool missing_ok = 2 [json_name = "missing_ok"];
inline void DropTableSpaceStmt::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool DropTableSpaceStmt::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool DropTableSpaceStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.DropTableSpaceStmt.missing_ok)
  return _internal_missing_ok();
}
inline void DropTableSpaceStmt::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void DropTableSpaceStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.DropTableSpaceStmt.missing_ok)
}

// -------------------------------------------------------------------

// AlterObjectDependsStmt

// .pg_query.ObjectType object_type = 1 [json_name = "objectType"];
inline void AlterObjectDependsStmt::clear_object_type() {
  object_type_ = 0;
}
inline ::pg_query::ObjectType AlterObjectDependsStmt::_internal_object_type() const {
  return static_cast< ::pg_query::ObjectType >(object_type_);
}
inline ::pg_query::ObjectType AlterObjectDependsStmt::object_type() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.object_type)
  return _internal_object_type();
}
inline void AlterObjectDependsStmt::_internal_set_object_type(::pg_query::ObjectType value) {
  
  object_type_ = value;
}
inline void AlterObjectDependsStmt::set_object_type(::pg_query::ObjectType value) {
  _internal_set_object_type(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterObjectDependsStmt.object_type)
}

// .pg_query.RangeVar relation = 2 [json_name = "relation"];
inline bool AlterObjectDependsStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool AlterObjectDependsStmt::has_relation() const {
  return _internal_has_relation();
}
inline void AlterObjectDependsStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& AlterObjectDependsStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& AlterObjectDependsStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.relation)
  return _internal_relation();
}
inline void AlterObjectDependsStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectDependsStmt.relation)
}
inline ::pg_query::RangeVar* AlterObjectDependsStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* AlterObjectDependsStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.AlterObjectDependsStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* AlterObjectDependsStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* AlterObjectDependsStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterObjectDependsStmt.relation)
  return _internal_mutable_relation();
}
inline void AlterObjectDependsStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectDependsStmt.relation)
}

// .pg_query.Node object = 3 [json_name = "object"];
inline bool AlterObjectDependsStmt::_internal_has_object() const {
  return this != internal_default_instance() && object_ != nullptr;
}
inline bool AlterObjectDependsStmt::has_object() const {
  return _internal_has_object();
}
inline void AlterObjectDependsStmt::clear_object() {
  if (GetArena() == nullptr && object_ != nullptr) {
    delete object_;
  }
  object_ = nullptr;
}
inline const ::pg_query::Node& AlterObjectDependsStmt::_internal_object() const {
  const ::pg_query::Node* p = object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterObjectDependsStmt::object() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.object)
  return _internal_object();
}
inline void AlterObjectDependsStmt::unsafe_arena_set_allocated_object(
    ::pg_query::Node* object) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(object_);
  }
  object_ = object;
  if (object) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectDependsStmt.object)
}
inline ::pg_query::Node* AlterObjectDependsStmt::release_object() {
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* AlterObjectDependsStmt::unsafe_arena_release_object() {
  // @@protoc_insertion_point(field_release:pg_query.AlterObjectDependsStmt.object)
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterObjectDependsStmt::_internal_mutable_object() {
  
  if (object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    object_ = p;
  }
  return object_;
}
inline ::pg_query::Node* AlterObjectDependsStmt::mutable_object() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterObjectDependsStmt.object)
  return _internal_mutable_object();
}
inline void AlterObjectDependsStmt::set_allocated_object(::pg_query::Node* object) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete object_;
  }
  if (object) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(object);
    if (message_arena != submessage_arena) {
      object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, object, submessage_arena);
    }
    
  } else {
    
  }
  object_ = object;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectDependsStmt.object)
}

// .pg_query.Node extname = 4 [json_name = "extname"];
inline bool AlterObjectDependsStmt::_internal_has_extname() const {
  return this != internal_default_instance() && extname_ != nullptr;
}
inline bool AlterObjectDependsStmt::has_extname() const {
  return _internal_has_extname();
}
inline void AlterObjectDependsStmt::clear_extname() {
  if (GetArena() == nullptr && extname_ != nullptr) {
    delete extname_;
  }
  extname_ = nullptr;
}
inline const ::pg_query::Node& AlterObjectDependsStmt::_internal_extname() const {
  const ::pg_query::Node* p = extname_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterObjectDependsStmt::extname() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.extname)
  return _internal_extname();
}
inline void AlterObjectDependsStmt::unsafe_arena_set_allocated_extname(
    ::pg_query::Node* extname) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(extname_);
  }
  extname_ = extname;
  if (extname) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectDependsStmt.extname)
}
inline ::pg_query::Node* AlterObjectDependsStmt::release_extname() {
  
  ::pg_query::Node* temp = extname_;
  extname_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* AlterObjectDependsStmt::unsafe_arena_release_extname() {
  // @@protoc_insertion_point(field_release:pg_query.AlterObjectDependsStmt.extname)
  
  ::pg_query::Node* temp = extname_;
  extname_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterObjectDependsStmt::_internal_mutable_extname() {
  
  if (extname_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    extname_ = p;
  }
  return extname_;
}
inline ::pg_query::Node* AlterObjectDependsStmt::mutable_extname() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterObjectDependsStmt.extname)
  return _internal_mutable_extname();
}
inline void AlterObjectDependsStmt::set_allocated_extname(::pg_query::Node* extname) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete extname_;
  }
  if (extname) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extname);
    if (message_arena != submessage_arena) {
      extname = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, extname, submessage_arena);
    }
    
  } else {
    
  }
  extname_ = extname;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectDependsStmt.extname)
}

// bool remove = 5 [json_name = "remove"];
inline void AlterObjectDependsStmt::clear_remove() {
  remove_ = false;
}
inline bool AlterObjectDependsStmt::_internal_remove() const {
  return remove_;
}
inline bool AlterObjectDependsStmt::remove() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.remove)
  return _internal_remove();
}
inline void AlterObjectDependsStmt::_internal_set_remove(bool value) {
  
  remove_ = value;
}
inline void AlterObjectDependsStmt::set_remove(bool value) {
  _internal_set_remove(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterObjectDependsStmt.remove)
}

// -------------------------------------------------------------------

// AlterObjectSchemaStmt

// .pg_query.ObjectType object_type = 1 [json_name = "objectType"];
inline void AlterObjectSchemaStmt::clear_object_type() {
  object_type_ = 0;
}
inline ::pg_query::ObjectType AlterObjectSchemaStmt::_internal_object_type() const {
  return static_cast< ::pg_query::ObjectType >(object_type_);
}
inline ::pg_query::ObjectType AlterObjectSchemaStmt::object_type() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.object_type)
  return _internal_object_type();
}
inline void AlterObjectSchemaStmt::_internal_set_object_type(::pg_query::ObjectType value) {
  
  object_type_ = value;
}
inline void AlterObjectSchemaStmt::set_object_type(::pg_query::ObjectType value) {
  _internal_set_object_type(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterObjectSchemaStmt.object_type)
}

// .pg_query.RangeVar relation = 2 [json_name = "relation"];
inline bool AlterObjectSchemaStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool AlterObjectSchemaStmt::has_relation() const {
  return _internal_has_relation();
}
inline void AlterObjectSchemaStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& AlterObjectSchemaStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& AlterObjectSchemaStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.relation)
  return _internal_relation();
}
inline void AlterObjectSchemaStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectSchemaStmt.relation)
}
inline ::pg_query::RangeVar* AlterObjectSchemaStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* AlterObjectSchemaStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.AlterObjectSchemaStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* AlterObjectSchemaStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* AlterObjectSchemaStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterObjectSchemaStmt.relation)
  return _internal_mutable_relation();
}
inline void AlterObjectSchemaStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectSchemaStmt.relation)
}

// .pg_query.Node object = 3 [json_name = "object"];
inline bool AlterObjectSchemaStmt::_internal_has_object() const {
  return this != internal_default_instance() && object_ != nullptr;
}
inline bool AlterObjectSchemaStmt::has_object() const {
  return _internal_has_object();
}
inline void AlterObjectSchemaStmt::clear_object() {
  if (GetArena() == nullptr && object_ != nullptr) {
    delete object_;
  }
  object_ = nullptr;
}
inline const ::pg_query::Node& AlterObjectSchemaStmt::_internal_object() const {
  const ::pg_query::Node* p = object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterObjectSchemaStmt::object() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.object)
  return _internal_object();
}
inline void AlterObjectSchemaStmt::unsafe_arena_set_allocated_object(
    ::pg_query::Node* object) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(object_);
  }
  object_ = object;
  if (object) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectSchemaStmt.object)
}
inline ::pg_query::Node* AlterObjectSchemaStmt::release_object() {
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* AlterObjectSchemaStmt::unsafe_arena_release_object() {
  // @@protoc_insertion_point(field_release:pg_query.AlterObjectSchemaStmt.object)
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterObjectSchemaStmt::_internal_mutable_object() {
  
  if (object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    object_ = p;
  }
  return object_;
}
inline ::pg_query::Node* AlterObjectSchemaStmt::mutable_object() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterObjectSchemaStmt.object)
  return _internal_mutable_object();
}
inline void AlterObjectSchemaStmt::set_allocated_object(::pg_query::Node* object) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete object_;
  }
  if (object) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(object);
    if (message_arena != submessage_arena) {
      object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, object, submessage_arena);
    }
    
  } else {
    
  }
  object_ = object;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectSchemaStmt.object)
}

// string newschema = 4 [json_name = "newschema"];
inline void AlterObjectSchemaStmt::clear_newschema() {
  newschema_.ClearToEmpty();
}
inline const std::string& AlterObjectSchemaStmt::newschema() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.newschema)
  return _internal_newschema();
}
inline void AlterObjectSchemaStmt::set_newschema(const std::string& value) {
  _internal_set_newschema(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterObjectSchemaStmt.newschema)
}
inline std::string* AlterObjectSchemaStmt::mutable_newschema() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterObjectSchemaStmt.newschema)
  return _internal_mutable_newschema();
}
inline const std::string& AlterObjectSchemaStmt::_internal_newschema() const {
  return newschema_.Get();
}
inline void AlterObjectSchemaStmt::_internal_set_newschema(const std::string& value) {
  
  newschema_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterObjectSchemaStmt::set_newschema(std::string&& value) {
  
  newschema_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterObjectSchemaStmt.newschema)
}
inline void AlterObjectSchemaStmt::set_newschema(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  newschema_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterObjectSchemaStmt.newschema)
}
inline void AlterObjectSchemaStmt::set_newschema(const char* value,
    size_t size) {
  
  newschema_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterObjectSchemaStmt.newschema)
}
inline std::string* AlterObjectSchemaStmt::_internal_mutable_newschema() {
  
  return newschema_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterObjectSchemaStmt::release_newschema() {
  // @@protoc_insertion_point(field_release:pg_query.AlterObjectSchemaStmt.newschema)
  return newschema_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterObjectSchemaStmt::set_allocated_newschema(std::string* newschema) {
  if (newschema != nullptr) {
    
  } else {
    
  }
  newschema_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), newschema,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectSchemaStmt.newschema)
}

// bool missing_ok = 5 [json_name = "missing_ok"];
inline void AlterObjectSchemaStmt::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool AlterObjectSchemaStmt::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool AlterObjectSchemaStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.missing_ok)
  return _internal_missing_ok();
}
inline void AlterObjectSchemaStmt::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void AlterObjectSchemaStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterObjectSchemaStmt.missing_ok)
}

// -------------------------------------------------------------------

// AlterOwnerStmt

// .pg_query.ObjectType object_type = 1 [json_name = "objectType"];
inline void AlterOwnerStmt::clear_object_type() {
  object_type_ = 0;
}
inline ::pg_query::ObjectType AlterOwnerStmt::_internal_object_type() const {
  return static_cast< ::pg_query::ObjectType >(object_type_);
}
inline ::pg_query::ObjectType AlterOwnerStmt::object_type() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterOwnerStmt.object_type)
  return _internal_object_type();
}
inline void AlterOwnerStmt::_internal_set_object_type(::pg_query::ObjectType value) {
  
  object_type_ = value;
}
inline void AlterOwnerStmt::set_object_type(::pg_query::ObjectType value) {
  _internal_set_object_type(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterOwnerStmt.object_type)
}

// .pg_query.RangeVar relation = 2 [json_name = "relation"];
inline bool AlterOwnerStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool AlterOwnerStmt::has_relation() const {
  return _internal_has_relation();
}
inline void AlterOwnerStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& AlterOwnerStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& AlterOwnerStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterOwnerStmt.relation)
  return _internal_relation();
}
inline void AlterOwnerStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterOwnerStmt.relation)
}
inline ::pg_query::RangeVar* AlterOwnerStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* AlterOwnerStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.AlterOwnerStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* AlterOwnerStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* AlterOwnerStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOwnerStmt.relation)
  return _internal_mutable_relation();
}
inline void AlterOwnerStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterOwnerStmt.relation)
}

// .pg_query.Node object = 3 [json_name = "object"];
inline bool AlterOwnerStmt::_internal_has_object() const {
  return this != internal_default_instance() && object_ != nullptr;
}
inline bool AlterOwnerStmt::has_object() const {
  return _internal_has_object();
}
inline void AlterOwnerStmt::clear_object() {
  if (GetArena() == nullptr && object_ != nullptr) {
    delete object_;
  }
  object_ = nullptr;
}
inline const ::pg_query::Node& AlterOwnerStmt::_internal_object() const {
  const ::pg_query::Node* p = object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterOwnerStmt::object() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterOwnerStmt.object)
  return _internal_object();
}
inline void AlterOwnerStmt::unsafe_arena_set_allocated_object(
    ::pg_query::Node* object) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(object_);
  }
  object_ = object;
  if (object) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterOwnerStmt.object)
}
inline ::pg_query::Node* AlterOwnerStmt::release_object() {
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* AlterOwnerStmt::unsafe_arena_release_object() {
  // @@protoc_insertion_point(field_release:pg_query.AlterOwnerStmt.object)
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterOwnerStmt::_internal_mutable_object() {
  
  if (object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    object_ = p;
  }
  return object_;
}
inline ::pg_query::Node* AlterOwnerStmt::mutable_object() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOwnerStmt.object)
  return _internal_mutable_object();
}
inline void AlterOwnerStmt::set_allocated_object(::pg_query::Node* object) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete object_;
  }
  if (object) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(object);
    if (message_arena != submessage_arena) {
      object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, object, submessage_arena);
    }
    
  } else {
    
  }
  object_ = object;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterOwnerStmt.object)
}

// .pg_query.RoleSpec newowner = 4 [json_name = "newowner"];
inline bool AlterOwnerStmt::_internal_has_newowner() const {
  return this != internal_default_instance() && newowner_ != nullptr;
}
inline bool AlterOwnerStmt::has_newowner() const {
  return _internal_has_newowner();
}
inline void AlterOwnerStmt::clear_newowner() {
  if (GetArena() == nullptr && newowner_ != nullptr) {
    delete newowner_;
  }
  newowner_ = nullptr;
}
inline const ::pg_query::RoleSpec& AlterOwnerStmt::_internal_newowner() const {
  const ::pg_query::RoleSpec* p = newowner_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(
      ::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& AlterOwnerStmt::newowner() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterOwnerStmt.newowner)
  return _internal_newowner();
}
inline void AlterOwnerStmt::unsafe_arena_set_allocated_newowner(
    ::pg_query::RoleSpec* newowner) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(newowner_);
  }
  newowner_ = newowner;
  if (newowner) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterOwnerStmt.newowner)
}
inline ::pg_query::RoleSpec* AlterOwnerStmt::release_newowner() {
  
  ::pg_query::RoleSpec* temp = newowner_;
  newowner_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RoleSpec* AlterOwnerStmt::unsafe_arena_release_newowner() {
  // @@protoc_insertion_point(field_release:pg_query.AlterOwnerStmt.newowner)
  
  ::pg_query::RoleSpec* temp = newowner_;
  newowner_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* AlterOwnerStmt::_internal_mutable_newowner() {
  
  if (newowner_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    newowner_ = p;
  }
  return newowner_;
}
inline ::pg_query::RoleSpec* AlterOwnerStmt::mutable_newowner() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOwnerStmt.newowner)
  return _internal_mutable_newowner();
}
inline void AlterOwnerStmt::set_allocated_newowner(::pg_query::RoleSpec* newowner) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete newowner_;
  }
  if (newowner) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(newowner);
    if (message_arena != submessage_arena) {
      newowner = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, newowner, submessage_arena);
    }
    
  } else {
    
  }
  newowner_ = newowner;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterOwnerStmt.newowner)
}

// -------------------------------------------------------------------

// AlterOperatorStmt

// .pg_query.ObjectWithArgs opername = 1 [json_name = "opername"];
inline bool AlterOperatorStmt::_internal_has_opername() const {
  return this != internal_default_instance() && opername_ != nullptr;
}
inline bool AlterOperatorStmt::has_opername() const {
  return _internal_has_opername();
}
inline void AlterOperatorStmt::clear_opername() {
  if (GetArena() == nullptr && opername_ != nullptr) {
    delete opername_;
  }
  opername_ = nullptr;
}
inline const ::pg_query::ObjectWithArgs& AlterOperatorStmt::_internal_opername() const {
  const ::pg_query::ObjectWithArgs* p = opername_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::ObjectWithArgs&>(
      ::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& AlterOperatorStmt::opername() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterOperatorStmt.opername)
  return _internal_opername();
}
inline void AlterOperatorStmt::unsafe_arena_set_allocated_opername(
    ::pg_query::ObjectWithArgs* opername) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(opername_);
  }
  opername_ = opername;
  if (opername) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterOperatorStmt.opername)
}
inline ::pg_query::ObjectWithArgs* AlterOperatorStmt::release_opername() {
  
  ::pg_query::ObjectWithArgs* temp = opername_;
  opername_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::ObjectWithArgs* AlterOperatorStmt::unsafe_arena_release_opername() {
  // @@protoc_insertion_point(field_release:pg_query.AlterOperatorStmt.opername)
  
  ::pg_query::ObjectWithArgs* temp = opername_;
  opername_ = nullptr;
  return temp;
}
inline ::pg_query::ObjectWithArgs* AlterOperatorStmt::_internal_mutable_opername() {
  
  if (opername_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArena());
    opername_ = p;
  }
  return opername_;
}
inline ::pg_query::ObjectWithArgs* AlterOperatorStmt::mutable_opername() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOperatorStmt.opername)
  return _internal_mutable_opername();
}
inline void AlterOperatorStmt::set_allocated_opername(::pg_query::ObjectWithArgs* opername) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete opername_;
  }
  if (opername) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(opername);
    if (message_arena != submessage_arena) {
      opername = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, opername, submessage_arena);
    }
    
  } else {
    
  }
  opername_ = opername;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterOperatorStmt.opername)
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int AlterOperatorStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterOperatorStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterOperatorStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterOperatorStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOperatorStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterOperatorStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterOperatorStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterOperatorStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterOperatorStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterOperatorStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterOperatorStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterOperatorStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterOperatorStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterOperatorStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterOperatorStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// AlterTypeStmt

// repeated .pg_query.Node type_name = 1 [json_name = "typeName"];
inline int AlterTypeStmt::_internal_type_name_size() const {
  return type_name_.size();
}
inline int AlterTypeStmt::type_name_size() const {
  return _internal_type_name_size();
}
inline void AlterTypeStmt::clear_type_name() {
  type_name_.Clear();
}
inline ::pg_query::Node* AlterTypeStmt::mutable_type_name(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTypeStmt.type_name)
  return type_name_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterTypeStmt::mutable_type_name() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTypeStmt.type_name)
  return &type_name_;
}
inline const ::pg_query::Node& AlterTypeStmt::_internal_type_name(int index) const {
  return type_name_.Get(index);
}
inline const ::pg_query::Node& AlterTypeStmt::type_name(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTypeStmt.type_name)
  return _internal_type_name(index);
}
inline ::pg_query::Node* AlterTypeStmt::_internal_add_type_name() {
  return type_name_.Add();
}
inline ::pg_query::Node* AlterTypeStmt::add_type_name() {
  // @@protoc_insertion_point(field_add:pg_query.AlterTypeStmt.type_name)
  return _internal_add_type_name();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterTypeStmt::type_name() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterTypeStmt.type_name)
  return type_name_;
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int AlterTypeStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterTypeStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterTypeStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterTypeStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTypeStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterTypeStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTypeStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterTypeStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterTypeStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTypeStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterTypeStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterTypeStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterTypeStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterTypeStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterTypeStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// DropOwnedStmt

// repeated .pg_query.Node roles = 1 [json_name = "roles"];
inline int DropOwnedStmt::_internal_roles_size() const {
  return roles_.size();
}
inline int DropOwnedStmt::roles_size() const {
  return _internal_roles_size();
}
inline void DropOwnedStmt::clear_roles() {
  roles_.Clear();
}
inline ::pg_query::Node* DropOwnedStmt::mutable_roles(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.DropOwnedStmt.roles)
  return roles_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
DropOwnedStmt::mutable_roles() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DropOwnedStmt.roles)
  return &roles_;
}
inline const ::pg_query::Node& DropOwnedStmt::_internal_roles(int index) const {
  return roles_.Get(index);
}
inline const ::pg_query::Node& DropOwnedStmt::roles(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.DropOwnedStmt.roles)
  return _internal_roles(index);
}
inline ::pg_query::Node* DropOwnedStmt::_internal_add_roles() {
  return roles_.Add();
}
inline ::pg_query::Node* DropOwnedStmt::add_roles() {
  // @@protoc_insertion_point(field_add:pg_query.DropOwnedStmt.roles)
  return _internal_add_roles();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
DropOwnedStmt::roles() const {
  // @@protoc_insertion_point(field_list:pg_query.DropOwnedStmt.roles)
  return roles_;
}

// .pg_query.DropBehavior behavior = 2 [json_name = "behavior"];
inline void DropOwnedStmt::clear_behavior() {
  behavior_ = 0;
}
inline ::pg_query::DropBehavior DropOwnedStmt::_internal_behavior() const {
  return static_cast< ::pg_query::DropBehavior >(behavior_);
}
inline ::pg_query::DropBehavior DropOwnedStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.DropOwnedStmt.behavior)
  return _internal_behavior();
}
inline void DropOwnedStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  
  behavior_ = value;
}
inline void DropOwnedStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.DropOwnedStmt.behavior)
}

// -------------------------------------------------------------------

// ReassignOwnedStmt

// repeated .pg_query.Node roles = 1 [json_name = "roles"];
inline int ReassignOwnedStmt::_internal_roles_size() const {
  return roles_.size();
}
inline int ReassignOwnedStmt::roles_size() const {
  return _internal_roles_size();
}
inline void ReassignOwnedStmt::clear_roles() {
  roles_.Clear();
}
inline ::pg_query::Node* ReassignOwnedStmt::mutable_roles(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ReassignOwnedStmt.roles)
  return roles_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ReassignOwnedStmt::mutable_roles() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ReassignOwnedStmt.roles)
  return &roles_;
}
inline const ::pg_query::Node& ReassignOwnedStmt::_internal_roles(int index) const {
  return roles_.Get(index);
}
inline const ::pg_query::Node& ReassignOwnedStmt::roles(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ReassignOwnedStmt.roles)
  return _internal_roles(index);
}
inline ::pg_query::Node* ReassignOwnedStmt::_internal_add_roles() {
  return roles_.Add();
}
inline ::pg_query::Node* ReassignOwnedStmt::add_roles() {
  // @@protoc_insertion_point(field_add:pg_query.ReassignOwnedStmt.roles)
  return _internal_add_roles();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ReassignOwnedStmt::roles() const {
  // @@protoc_insertion_point(field_list:pg_query.ReassignOwnedStmt.roles)
  return roles_;
}

// .pg_query.RoleSpec newrole = 2 [json_name = "newrole"];
inline bool ReassignOwnedStmt::_internal_has_newrole() const {
  return this != internal_default_instance() && newrole_ != nullptr;
}
inline bool ReassignOwnedStmt::has_newrole() const {
  return _internal_has_newrole();
}
inline void ReassignOwnedStmt::clear_newrole() {
  if (GetArena() == nullptr && newrole_ != nullptr) {
    delete newrole_;
  }
  newrole_ = nullptr;
}
inline const ::pg_query::RoleSpec& ReassignOwnedStmt::_internal_newrole() const {
  const ::pg_query::RoleSpec* p = newrole_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(
      ::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& ReassignOwnedStmt::newrole() const {
  // @@protoc_insertion_point(field_get:pg_query.ReassignOwnedStmt.newrole)
  return _internal_newrole();
}
inline void ReassignOwnedStmt::unsafe_arena_set_allocated_newrole(
    ::pg_query::RoleSpec* newrole) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(newrole_);
  }
  newrole_ = newrole;
  if (newrole) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ReassignOwnedStmt.newrole)
}
inline ::pg_query::RoleSpec* ReassignOwnedStmt::release_newrole() {
  
  ::pg_query::RoleSpec* temp = newrole_;
  newrole_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RoleSpec* ReassignOwnedStmt::unsafe_arena_release_newrole() {
  // @@protoc_insertion_point(field_release:pg_query.ReassignOwnedStmt.newrole)
  
  ::pg_query::RoleSpec* temp = newrole_;
  newrole_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* ReassignOwnedStmt::_internal_mutable_newrole() {
  
  if (newrole_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    newrole_ = p;
  }
  return newrole_;
}
inline ::pg_query::RoleSpec* ReassignOwnedStmt::mutable_newrole() {
  // @@protoc_insertion_point(field_mutable:pg_query.ReassignOwnedStmt.newrole)
  return _internal_mutable_newrole();
}
inline void ReassignOwnedStmt::set_allocated_newrole(::pg_query::RoleSpec* newrole) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete newrole_;
  }
  if (newrole) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(newrole);
    if (message_arena != submessage_arena) {
      newrole = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, newrole, submessage_arena);
    }
    
  } else {
    
  }
  newrole_ = newrole;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ReassignOwnedStmt.newrole)
}

// -------------------------------------------------------------------

// CompositeTypeStmt

// .pg_query.RangeVar typevar = 1 [json_name = "typevar"];
inline bool CompositeTypeStmt::_internal_has_typevar() const {
  return this != internal_default_instance() && typevar_ != nullptr;
}
inline bool CompositeTypeStmt::has_typevar() const {
  return _internal_has_typevar();
}
inline void CompositeTypeStmt::clear_typevar() {
  if (GetArena() == nullptr && typevar_ != nullptr) {
    delete typevar_;
  }
  typevar_ = nullptr;
}
inline const ::pg_query::RangeVar& CompositeTypeStmt::_internal_typevar() const {
  const ::pg_query::RangeVar* p = typevar_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CompositeTypeStmt::typevar() const {
  // @@protoc_insertion_point(field_get:pg_query.CompositeTypeStmt.typevar)
  return _internal_typevar();
}
inline void CompositeTypeStmt::unsafe_arena_set_allocated_typevar(
    ::pg_query::RangeVar* typevar) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(typevar_);
  }
  typevar_ = typevar;
  if (typevar) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CompositeTypeStmt.typevar)
}
inline ::pg_query::RangeVar* CompositeTypeStmt::release_typevar() {
  
  ::pg_query::RangeVar* temp = typevar_;
  typevar_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* CompositeTypeStmt::unsafe_arena_release_typevar() {
  // @@protoc_insertion_point(field_release:pg_query.CompositeTypeStmt.typevar)
  
  ::pg_query::RangeVar* temp = typevar_;
  typevar_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CompositeTypeStmt::_internal_mutable_typevar() {
  
  if (typevar_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    typevar_ = p;
  }
  return typevar_;
}
inline ::pg_query::RangeVar* CompositeTypeStmt::mutable_typevar() {
  // @@protoc_insertion_point(field_mutable:pg_query.CompositeTypeStmt.typevar)
  return _internal_mutable_typevar();
}
inline void CompositeTypeStmt::set_allocated_typevar(::pg_query::RangeVar* typevar) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete typevar_;
  }
  if (typevar) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(typevar);
    if (message_arena != submessage_arena) {
      typevar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, typevar, submessage_arena);
    }
    
  } else {
    
  }
  typevar_ = typevar;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CompositeTypeStmt.typevar)
}

// repeated .pg_query.Node coldeflist = 2 [json_name = "coldeflist"];
inline int CompositeTypeStmt::_internal_coldeflist_size() const {
  return coldeflist_.size();
}
inline int CompositeTypeStmt::coldeflist_size() const {
  return _internal_coldeflist_size();
}
inline void CompositeTypeStmt::clear_coldeflist() {
  coldeflist_.Clear();
}
inline ::pg_query::Node* CompositeTypeStmt::mutable_coldeflist(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CompositeTypeStmt.coldeflist)
  return coldeflist_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CompositeTypeStmt::mutable_coldeflist() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CompositeTypeStmt.coldeflist)
  return &coldeflist_;
}
inline const ::pg_query::Node& CompositeTypeStmt::_internal_coldeflist(int index) const {
  return coldeflist_.Get(index);
}
inline const ::pg_query::Node& CompositeTypeStmt::coldeflist(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CompositeTypeStmt.coldeflist)
  return _internal_coldeflist(index);
}
inline ::pg_query::Node* CompositeTypeStmt::_internal_add_coldeflist() {
  return coldeflist_.Add();
}
inline ::pg_query::Node* CompositeTypeStmt::add_coldeflist() {
  // @@protoc_insertion_point(field_add:pg_query.CompositeTypeStmt.coldeflist)
  return _internal_add_coldeflist();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CompositeTypeStmt::coldeflist() const {
  // @@protoc_insertion_point(field_list:pg_query.CompositeTypeStmt.coldeflist)
  return coldeflist_;
}

// -------------------------------------------------------------------

// CreateEnumStmt

// repeated .pg_query.Node type_name = 1 [json_name = "typeName"];
inline int CreateEnumStmt::_internal_type_name_size() const {
  return type_name_.size();
}
inline int CreateEnumStmt::type_name_size() const {
  return _internal_type_name_size();
}
inline void CreateEnumStmt::clear_type_name() {
  type_name_.Clear();
}
inline ::pg_query::Node* CreateEnumStmt::mutable_type_name(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateEnumStmt.type_name)
  return type_name_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateEnumStmt::mutable_type_name() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateEnumStmt.type_name)
  return &type_name_;
}
inline const ::pg_query::Node& CreateEnumStmt::_internal_type_name(int index) const {
  return type_name_.Get(index);
}
inline const ::pg_query::Node& CreateEnumStmt::type_name(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateEnumStmt.type_name)
  return _internal_type_name(index);
}
inline ::pg_query::Node* CreateEnumStmt::_internal_add_type_name() {
  return type_name_.Add();
}
inline ::pg_query::Node* CreateEnumStmt::add_type_name() {
  // @@protoc_insertion_point(field_add:pg_query.CreateEnumStmt.type_name)
  return _internal_add_type_name();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateEnumStmt::type_name() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateEnumStmt.type_name)
  return type_name_;
}

// repeated .pg_query.Node vals = 2 [json_name = "vals"];
inline int CreateEnumStmt::_internal_vals_size() const {
  return vals_.size();
}
inline int CreateEnumStmt::vals_size() const {
  return _internal_vals_size();
}
inline void CreateEnumStmt::clear_vals() {
  vals_.Clear();
}
inline ::pg_query::Node* CreateEnumStmt::mutable_vals(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateEnumStmt.vals)
  return vals_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateEnumStmt::mutable_vals() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateEnumStmt.vals)
  return &vals_;
}
inline const ::pg_query::Node& CreateEnumStmt::_internal_vals(int index) const {
  return vals_.Get(index);
}
inline const ::pg_query::Node& CreateEnumStmt::vals(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateEnumStmt.vals)
  return _internal_vals(index);
}
inline ::pg_query::Node* CreateEnumStmt::_internal_add_vals() {
  return vals_.Add();
}
inline ::pg_query::Node* CreateEnumStmt::add_vals() {
  // @@protoc_insertion_point(field_add:pg_query.CreateEnumStmt.vals)
  return _internal_add_vals();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateEnumStmt::vals() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateEnumStmt.vals)
  return vals_;
}

// -------------------------------------------------------------------

// CreateRangeStmt

// repeated .pg_query.Node type_name = 1 [json_name = "typeName"];
inline int CreateRangeStmt::_internal_type_name_size() const {
  return type_name_.size();
}
inline int CreateRangeStmt::type_name_size() const {
  return _internal_type_name_size();
}
inline void CreateRangeStmt::clear_type_name() {
  type_name_.Clear();
}
inline ::pg_query::Node* CreateRangeStmt::mutable_type_name(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateRangeStmt.type_name)
  return type_name_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateRangeStmt::mutable_type_name() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateRangeStmt.type_name)
  return &type_name_;
}
inline const ::pg_query::Node& CreateRangeStmt::_internal_type_name(int index) const {
  return type_name_.Get(index);
}
inline const ::pg_query::Node& CreateRangeStmt::type_name(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateRangeStmt.type_name)
  return _internal_type_name(index);
}
inline ::pg_query::Node* CreateRangeStmt::_internal_add_type_name() {
  return type_name_.Add();
}
inline ::pg_query::Node* CreateRangeStmt::add_type_name() {
  // @@protoc_insertion_point(field_add:pg_query.CreateRangeStmt.type_name)
  return _internal_add_type_name();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateRangeStmt::type_name() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateRangeStmt.type_name)
  return type_name_;
}

// repeated .pg_query.Node params = 2 [json_name = "params"];
inline int CreateRangeStmt::_internal_params_size() const {
  return params_.size();
}
inline int CreateRangeStmt::params_size() const {
  return _internal_params_size();
}
inline void CreateRangeStmt::clear_params() {
  params_.Clear();
}
inline ::pg_query::Node* CreateRangeStmt::mutable_params(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateRangeStmt.params)
  return params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateRangeStmt::mutable_params() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateRangeStmt.params)
  return &params_;
}
inline const ::pg_query::Node& CreateRangeStmt::_internal_params(int index) const {
  return params_.Get(index);
}
inline const ::pg_query::Node& CreateRangeStmt::params(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateRangeStmt.params)
  return _internal_params(index);
}
inline ::pg_query::Node* CreateRangeStmt::_internal_add_params() {
  return params_.Add();
}
inline ::pg_query::Node* CreateRangeStmt::add_params() {
  // @@protoc_insertion_point(field_add:pg_query.CreateRangeStmt.params)
  return _internal_add_params();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateRangeStmt::params() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateRangeStmt.params)
  return params_;
}

// -------------------------------------------------------------------

// AlterEnumStmt

// repeated .pg_query.Node type_name = 1 [json_name = "typeName"];
inline int AlterEnumStmt::_internal_type_name_size() const {
  return type_name_.size();
}
inline int AlterEnumStmt::type_name_size() const {
  return _internal_type_name_size();
}
inline void AlterEnumStmt::clear_type_name() {
  type_name_.Clear();
}
inline ::pg_query::Node* AlterEnumStmt::mutable_type_name(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterEnumStmt.type_name)
  return type_name_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterEnumStmt::mutable_type_name() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterEnumStmt.type_name)
  return &type_name_;
}
inline const ::pg_query::Node& AlterEnumStmt::_internal_type_name(int index) const {
  return type_name_.Get(index);
}
inline const ::pg_query::Node& AlterEnumStmt::type_name(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.type_name)
  return _internal_type_name(index);
}
inline ::pg_query::Node* AlterEnumStmt::_internal_add_type_name() {
  return type_name_.Add();
}
inline ::pg_query::Node* AlterEnumStmt::add_type_name() {
  // @@protoc_insertion_point(field_add:pg_query.AlterEnumStmt.type_name)
  return _internal_add_type_name();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterEnumStmt::type_name() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterEnumStmt.type_name)
  return type_name_;
}

// string old_val = 2 [json_name = "oldVal"];
inline void AlterEnumStmt::clear_old_val() {
  old_val_.ClearToEmpty();
}
inline const std::string& AlterEnumStmt::old_val() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.old_val)
  return _internal_old_val();
}
inline void AlterEnumStmt::set_old_val(const std::string& value) {
  _internal_set_old_val(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterEnumStmt.old_val)
}
inline std::string* AlterEnumStmt::mutable_old_val() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterEnumStmt.old_val)
  return _internal_mutable_old_val();
}
inline const std::string& AlterEnumStmt::_internal_old_val() const {
  return old_val_.Get();
}
inline void AlterEnumStmt::_internal_set_old_val(const std::string& value) {
  
  old_val_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterEnumStmt::set_old_val(std::string&& value) {
  
  old_val_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterEnumStmt.old_val)
}
inline void AlterEnumStmt::set_old_val(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  old_val_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterEnumStmt.old_val)
}
inline void AlterEnumStmt::set_old_val(const char* value,
    size_t size) {
  
  old_val_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterEnumStmt.old_val)
}
inline std::string* AlterEnumStmt::_internal_mutable_old_val() {
  
  return old_val_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterEnumStmt::release_old_val() {
  // @@protoc_insertion_point(field_release:pg_query.AlterEnumStmt.old_val)
  return old_val_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterEnumStmt::set_allocated_old_val(std::string* old_val) {
  if (old_val != nullptr) {
    
  } else {
    
  }
  old_val_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), old_val,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterEnumStmt.old_val)
}

// string new_val = 3 [json_name = "newVal"];
inline void AlterEnumStmt::clear_new_val() {
  new_val_.ClearToEmpty();
}
inline const std::string& AlterEnumStmt::new_val() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.new_val)
  return _internal_new_val();
}
inline void AlterEnumStmt::set_new_val(const std::string& value) {
  _internal_set_new_val(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterEnumStmt.new_val)
}
inline std::string* AlterEnumStmt::mutable_new_val() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterEnumStmt.new_val)
  return _internal_mutable_new_val();
}
inline const std::string& AlterEnumStmt::_internal_new_val() const {
  return new_val_.Get();
}
inline void AlterEnumStmt::_internal_set_new_val(const std::string& value) {
  
  new_val_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterEnumStmt::set_new_val(std::string&& value) {
  
  new_val_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterEnumStmt.new_val)
}
inline void AlterEnumStmt::set_new_val(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  new_val_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterEnumStmt.new_val)
}
inline void AlterEnumStmt::set_new_val(const char* value,
    size_t size) {
  
  new_val_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterEnumStmt.new_val)
}
inline std::string* AlterEnumStmt::_internal_mutable_new_val() {
  
  return new_val_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterEnumStmt::release_new_val() {
  // @@protoc_insertion_point(field_release:pg_query.AlterEnumStmt.new_val)
  return new_val_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterEnumStmt::set_allocated_new_val(std::string* new_val) {
  if (new_val != nullptr) {
    
  } else {
    
  }
  new_val_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), new_val,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterEnumStmt.new_val)
}

// string new_val_neighbor = 4 [json_name = "newValNeighbor"];
inline void AlterEnumStmt::clear_new_val_neighbor() {
  new_val_neighbor_.ClearToEmpty();
}
inline const std::string& AlterEnumStmt::new_val_neighbor() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.new_val_neighbor)
  return _internal_new_val_neighbor();
}
inline void AlterEnumStmt::set_new_val_neighbor(const std::string& value) {
  _internal_set_new_val_neighbor(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterEnumStmt.new_val_neighbor)
}
inline std::string* AlterEnumStmt::mutable_new_val_neighbor() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterEnumStmt.new_val_neighbor)
  return _internal_mutable_new_val_neighbor();
}
inline const std::string& AlterEnumStmt::_internal_new_val_neighbor() const {
  return new_val_neighbor_.Get();
}
inline void AlterEnumStmt::_internal_set_new_val_neighbor(const std::string& value) {
  
  new_val_neighbor_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterEnumStmt::set_new_val_neighbor(std::string&& value) {
  
  new_val_neighbor_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterEnumStmt.new_val_neighbor)
}
inline void AlterEnumStmt::set_new_val_neighbor(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  new_val_neighbor_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterEnumStmt.new_val_neighbor)
}
inline void AlterEnumStmt::set_new_val_neighbor(const char* value,
    size_t size) {
  
  new_val_neighbor_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterEnumStmt.new_val_neighbor)
}
inline std::string* AlterEnumStmt::_internal_mutable_new_val_neighbor() {
  
  return new_val_neighbor_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterEnumStmt::release_new_val_neighbor() {
  // @@protoc_insertion_point(field_release:pg_query.AlterEnumStmt.new_val_neighbor)
  return new_val_neighbor_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterEnumStmt::set_allocated_new_val_neighbor(std::string* new_val_neighbor) {
  if (new_val_neighbor != nullptr) {
    
  } else {
    
  }
  new_val_neighbor_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), new_val_neighbor,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterEnumStmt.new_val_neighbor)
}

// bool new_val_is_after = 5 [json_name = "newValIsAfter"];
inline void AlterEnumStmt::clear_new_val_is_after() {
  new_val_is_after_ = false;
}
inline bool AlterEnumStmt::_internal_new_val_is_after() const {
  return new_val_is_after_;
}
inline bool AlterEnumStmt::new_val_is_after() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.new_val_is_after)
  return _internal_new_val_is_after();
}
inline void AlterEnumStmt::_internal_set_new_val_is_after(bool value) {
  
  new_val_is_after_ = value;
}
inline void AlterEnumStmt::set_new_val_is_after(bool value) {
  _internal_set_new_val_is_after(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterEnumStmt.new_val_is_after)
}

// bool skip_if_new_val_exists = 6 [json_name = "skipIfNewValExists"];
inline void AlterEnumStmt::clear_skip_if_new_val_exists() {
  skip_if_new_val_exists_ = false;
}
inline bool AlterEnumStmt::_internal_skip_if_new_val_exists() const {
  return skip_if_new_val_exists_;
}
inline bool AlterEnumStmt::skip_if_new_val_exists() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.skip_if_new_val_exists)
  return _internal_skip_if_new_val_exists();
}
inline void AlterEnumStmt::_internal_set_skip_if_new_val_exists(bool value) {
  
  skip_if_new_val_exists_ = value;
}
inline void AlterEnumStmt::set_skip_if_new_val_exists(bool value) {
  _internal_set_skip_if_new_val_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterEnumStmt.skip_if_new_val_exists)
}

// -------------------------------------------------------------------

// AlterTSDictionaryStmt

// repeated .pg_query.Node dictname = 1 [json_name = "dictname"];
inline int AlterTSDictionaryStmt::_internal_dictname_size() const {
  return dictname_.size();
}
inline int AlterTSDictionaryStmt::dictname_size() const {
  return _internal_dictname_size();
}
inline void AlterTSDictionaryStmt::clear_dictname() {
  dictname_.Clear();
}
inline ::pg_query::Node* AlterTSDictionaryStmt::mutable_dictname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTSDictionaryStmt.dictname)
  return dictname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterTSDictionaryStmt::mutable_dictname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSDictionaryStmt.dictname)
  return &dictname_;
}
inline const ::pg_query::Node& AlterTSDictionaryStmt::_internal_dictname(int index) const {
  return dictname_.Get(index);
}
inline const ::pg_query::Node& AlterTSDictionaryStmt::dictname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSDictionaryStmt.dictname)
  return _internal_dictname(index);
}
inline ::pg_query::Node* AlterTSDictionaryStmt::_internal_add_dictname() {
  return dictname_.Add();
}
inline ::pg_query::Node* AlterTSDictionaryStmt::add_dictname() {
  // @@protoc_insertion_point(field_add:pg_query.AlterTSDictionaryStmt.dictname)
  return _internal_add_dictname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterTSDictionaryStmt::dictname() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterTSDictionaryStmt.dictname)
  return dictname_;
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int AlterTSDictionaryStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterTSDictionaryStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterTSDictionaryStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterTSDictionaryStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTSDictionaryStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterTSDictionaryStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSDictionaryStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterTSDictionaryStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterTSDictionaryStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSDictionaryStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterTSDictionaryStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterTSDictionaryStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterTSDictionaryStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterTSDictionaryStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterTSDictionaryStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// AlterTSConfigurationStmt

// .pg_query.AlterTSConfigType kind = 1 [json_name = "kind"];
inline void AlterTSConfigurationStmt::clear_kind() {
  kind_ = 0;
}
inline ::pg_query::AlterTSConfigType AlterTSConfigurationStmt::_internal_kind() const {
  return static_cast< ::pg_query::AlterTSConfigType >(kind_);
}
inline ::pg_query::AlterTSConfigType AlterTSConfigurationStmt::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.kind)
  return _internal_kind();
}
inline void AlterTSConfigurationStmt::_internal_set_kind(::pg_query::AlterTSConfigType value) {
  
  kind_ = value;
}
inline void AlterTSConfigurationStmt::set_kind(::pg_query::AlterTSConfigType value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTSConfigurationStmt.kind)
}

// repeated .pg_query.Node cfgname = 2 [json_name = "cfgname"];
inline int AlterTSConfigurationStmt::_internal_cfgname_size() const {
  return cfgname_.size();
}
inline int AlterTSConfigurationStmt::cfgname_size() const {
  return _internal_cfgname_size();
}
inline void AlterTSConfigurationStmt::clear_cfgname() {
  cfgname_.Clear();
}
inline ::pg_query::Node* AlterTSConfigurationStmt::mutable_cfgname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTSConfigurationStmt.cfgname)
  return cfgname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterTSConfigurationStmt::mutable_cfgname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSConfigurationStmt.cfgname)
  return &cfgname_;
}
inline const ::pg_query::Node& AlterTSConfigurationStmt::_internal_cfgname(int index) const {
  return cfgname_.Get(index);
}
inline const ::pg_query::Node& AlterTSConfigurationStmt::cfgname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.cfgname)
  return _internal_cfgname(index);
}
inline ::pg_query::Node* AlterTSConfigurationStmt::_internal_add_cfgname() {
  return cfgname_.Add();
}
inline ::pg_query::Node* AlterTSConfigurationStmt::add_cfgname() {
  // @@protoc_insertion_point(field_add:pg_query.AlterTSConfigurationStmt.cfgname)
  return _internal_add_cfgname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterTSConfigurationStmt::cfgname() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterTSConfigurationStmt.cfgname)
  return cfgname_;
}

// repeated .pg_query.Node tokentype = 3 [json_name = "tokentype"];
inline int AlterTSConfigurationStmt::_internal_tokentype_size() const {
  return tokentype_.size();
}
inline int AlterTSConfigurationStmt::tokentype_size() const {
  return _internal_tokentype_size();
}
inline void AlterTSConfigurationStmt::clear_tokentype() {
  tokentype_.Clear();
}
inline ::pg_query::Node* AlterTSConfigurationStmt::mutable_tokentype(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTSConfigurationStmt.tokentype)
  return tokentype_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterTSConfigurationStmt::mutable_tokentype() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSConfigurationStmt.tokentype)
  return &tokentype_;
}
inline const ::pg_query::Node& AlterTSConfigurationStmt::_internal_tokentype(int index) const {
  return tokentype_.Get(index);
}
inline const ::pg_query::Node& AlterTSConfigurationStmt::tokentype(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.tokentype)
  return _internal_tokentype(index);
}
inline ::pg_query::Node* AlterTSConfigurationStmt::_internal_add_tokentype() {
  return tokentype_.Add();
}
inline ::pg_query::Node* AlterTSConfigurationStmt::add_tokentype() {
  // @@protoc_insertion_point(field_add:pg_query.AlterTSConfigurationStmt.tokentype)
  return _internal_add_tokentype();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterTSConfigurationStmt::tokentype() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterTSConfigurationStmt.tokentype)
  return tokentype_;
}

// repeated .pg_query.Node dicts = 4 [json_name = "dicts"];
inline int AlterTSConfigurationStmt::_internal_dicts_size() const {
  return dicts_.size();
}
inline int AlterTSConfigurationStmt::dicts_size() const {
  return _internal_dicts_size();
}
inline void AlterTSConfigurationStmt::clear_dicts() {
  dicts_.Clear();
}
inline ::pg_query::Node* AlterTSConfigurationStmt::mutable_dicts(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTSConfigurationStmt.dicts)
  return dicts_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterTSConfigurationStmt::mutable_dicts() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSConfigurationStmt.dicts)
  return &dicts_;
}
inline const ::pg_query::Node& AlterTSConfigurationStmt::_internal_dicts(int index) const {
  return dicts_.Get(index);
}
inline const ::pg_query::Node& AlterTSConfigurationStmt::dicts(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.dicts)
  return _internal_dicts(index);
}
inline ::pg_query::Node* AlterTSConfigurationStmt::_internal_add_dicts() {
  return dicts_.Add();
}
inline ::pg_query::Node* AlterTSConfigurationStmt::add_dicts() {
  // @@protoc_insertion_point(field_add:pg_query.AlterTSConfigurationStmt.dicts)
  return _internal_add_dicts();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterTSConfigurationStmt::dicts() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterTSConfigurationStmt.dicts)
  return dicts_;
}

// bool override = 5 [json_name = "override"];
inline void AlterTSConfigurationStmt::clear_override() {
  override_ = false;
}
inline bool AlterTSConfigurationStmt::_internal_override() const {
  return override_;
}
inline bool AlterTSConfigurationStmt::override() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.override)
  return _internal_override();
}
inline void AlterTSConfigurationStmt::_internal_set_override(bool value) {
  
  override_ = value;
}
inline void AlterTSConfigurationStmt::set_override(bool value) {
  _internal_set_override(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTSConfigurationStmt.override)
}

// bool replace = 6 [json_name = "replace"];
inline void AlterTSConfigurationStmt::clear_replace() {
  replace_ = false;
}
inline bool AlterTSConfigurationStmt::_internal_replace() const {
  return replace_;
}
inline bool AlterTSConfigurationStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.replace)
  return _internal_replace();
}
inline void AlterTSConfigurationStmt::_internal_set_replace(bool value) {
  
  replace_ = value;
}
inline void AlterTSConfigurationStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTSConfigurationStmt.replace)
}

// bool missing_ok = 7 [json_name = "missing_ok"];
inline void AlterTSConfigurationStmt::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool AlterTSConfigurationStmt::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool AlterTSConfigurationStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.missing_ok)
  return _internal_missing_ok();
}
inline void AlterTSConfigurationStmt::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void AlterTSConfigurationStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTSConfigurationStmt.missing_ok)
}

// -------------------------------------------------------------------

// CreateFdwStmt

// string fdwname = 1 [json_name = "fdwname"];
inline void CreateFdwStmt::clear_fdwname() {
  fdwname_.ClearToEmpty();
}
inline const std::string& CreateFdwStmt::fdwname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateFdwStmt.fdwname)
  return _internal_fdwname();
}
inline void CreateFdwStmt::set_fdwname(const std::string& value) {
  _internal_set_fdwname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateFdwStmt.fdwname)
}
inline std::string* CreateFdwStmt::mutable_fdwname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFdwStmt.fdwname)
  return _internal_mutable_fdwname();
}
inline const std::string& CreateFdwStmt::_internal_fdwname() const {
  return fdwname_.Get();
}
inline void CreateFdwStmt::_internal_set_fdwname(const std::string& value) {
  
  fdwname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateFdwStmt::set_fdwname(std::string&& value) {
  
  fdwname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateFdwStmt.fdwname)
}
inline void CreateFdwStmt::set_fdwname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  fdwname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateFdwStmt.fdwname)
}
inline void CreateFdwStmt::set_fdwname(const char* value,
    size_t size) {
  
  fdwname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateFdwStmt.fdwname)
}
inline std::string* CreateFdwStmt::_internal_mutable_fdwname() {
  
  return fdwname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateFdwStmt::release_fdwname() {
  // @@protoc_insertion_point(field_release:pg_query.CreateFdwStmt.fdwname)
  return fdwname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateFdwStmt::set_allocated_fdwname(std::string* fdwname) {
  if (fdwname != nullptr) {
    
  } else {
    
  }
  fdwname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fdwname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateFdwStmt.fdwname)
}

// repeated .pg_query.Node func_options = 2 [json_name = "func_options"];
inline int CreateFdwStmt::_internal_func_options_size() const {
  return func_options_.size();
}
inline int CreateFdwStmt::func_options_size() const {
  return _internal_func_options_size();
}
inline void CreateFdwStmt::clear_func_options() {
  func_options_.Clear();
}
inline ::pg_query::Node* CreateFdwStmt::mutable_func_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFdwStmt.func_options)
  return func_options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateFdwStmt::mutable_func_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFdwStmt.func_options)
  return &func_options_;
}
inline const ::pg_query::Node& CreateFdwStmt::_internal_func_options(int index) const {
  return func_options_.Get(index);
}
inline const ::pg_query::Node& CreateFdwStmt::func_options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateFdwStmt.func_options)
  return _internal_func_options(index);
}
inline ::pg_query::Node* CreateFdwStmt::_internal_add_func_options() {
  return func_options_.Add();
}
inline ::pg_query::Node* CreateFdwStmt::add_func_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreateFdwStmt.func_options)
  return _internal_add_func_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateFdwStmt::func_options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateFdwStmt.func_options)
  return func_options_;
}

// repeated .pg_query.Node options = 3 [json_name = "options"];
inline int CreateFdwStmt::_internal_options_size() const {
  return options_.size();
}
inline int CreateFdwStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateFdwStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CreateFdwStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFdwStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateFdwStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFdwStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CreateFdwStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CreateFdwStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateFdwStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CreateFdwStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CreateFdwStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreateFdwStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateFdwStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateFdwStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// AlterFdwStmt

// string fdwname = 1 [json_name = "fdwname"];
inline void AlterFdwStmt::clear_fdwname() {
  fdwname_.ClearToEmpty();
}
inline const std::string& AlterFdwStmt::fdwname() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterFdwStmt.fdwname)
  return _internal_fdwname();
}
inline void AlterFdwStmt::set_fdwname(const std::string& value) {
  _internal_set_fdwname(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterFdwStmt.fdwname)
}
inline std::string* AlterFdwStmt::mutable_fdwname() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterFdwStmt.fdwname)
  return _internal_mutable_fdwname();
}
inline const std::string& AlterFdwStmt::_internal_fdwname() const {
  return fdwname_.Get();
}
inline void AlterFdwStmt::_internal_set_fdwname(const std::string& value) {
  
  fdwname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterFdwStmt::set_fdwname(std::string&& value) {
  
  fdwname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterFdwStmt.fdwname)
}
inline void AlterFdwStmt::set_fdwname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  fdwname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterFdwStmt.fdwname)
}
inline void AlterFdwStmt::set_fdwname(const char* value,
    size_t size) {
  
  fdwname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterFdwStmt.fdwname)
}
inline std::string* AlterFdwStmt::_internal_mutable_fdwname() {
  
  return fdwname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterFdwStmt::release_fdwname() {
  // @@protoc_insertion_point(field_release:pg_query.AlterFdwStmt.fdwname)
  return fdwname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterFdwStmt::set_allocated_fdwname(std::string* fdwname) {
  if (fdwname != nullptr) {
    
  } else {
    
  }
  fdwname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fdwname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterFdwStmt.fdwname)
}

// repeated .pg_query.Node func_options = 2 [json_name = "func_options"];
inline int AlterFdwStmt::_internal_func_options_size() const {
  return func_options_.size();
}
inline int AlterFdwStmt::func_options_size() const {
  return _internal_func_options_size();
}
inline void AlterFdwStmt::clear_func_options() {
  func_options_.Clear();
}
inline ::pg_query::Node* AlterFdwStmt::mutable_func_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterFdwStmt.func_options)
  return func_options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterFdwStmt::mutable_func_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterFdwStmt.func_options)
  return &func_options_;
}
inline const ::pg_query::Node& AlterFdwStmt::_internal_func_options(int index) const {
  return func_options_.Get(index);
}
inline const ::pg_query::Node& AlterFdwStmt::func_options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterFdwStmt.func_options)
  return _internal_func_options(index);
}
inline ::pg_query::Node* AlterFdwStmt::_internal_add_func_options() {
  return func_options_.Add();
}
inline ::pg_query::Node* AlterFdwStmt::add_func_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterFdwStmt.func_options)
  return _internal_add_func_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterFdwStmt::func_options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterFdwStmt.func_options)
  return func_options_;
}

// repeated .pg_query.Node options = 3 [json_name = "options"];
inline int AlterFdwStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterFdwStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterFdwStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterFdwStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterFdwStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterFdwStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterFdwStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterFdwStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterFdwStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterFdwStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterFdwStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterFdwStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterFdwStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterFdwStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterFdwStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// CreateForeignServerStmt

// string servername = 1 [json_name = "servername"];
inline void CreateForeignServerStmt::clear_servername() {
  servername_.ClearToEmpty();
}
inline const std::string& CreateForeignServerStmt::servername() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.servername)
  return _internal_servername();
}
inline void CreateForeignServerStmt::set_servername(const std::string& value) {
  _internal_set_servername(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.servername)
}
inline std::string* CreateForeignServerStmt::mutable_servername() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignServerStmt.servername)
  return _internal_mutable_servername();
}
inline const std::string& CreateForeignServerStmt::_internal_servername() const {
  return servername_.Get();
}
inline void CreateForeignServerStmt::_internal_set_servername(const std::string& value) {
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateForeignServerStmt::set_servername(std::string&& value) {
  
  servername_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateForeignServerStmt.servername)
}
inline void CreateForeignServerStmt::set_servername(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateForeignServerStmt.servername)
}
inline void CreateForeignServerStmt::set_servername(const char* value,
    size_t size) {
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateForeignServerStmt.servername)
}
inline std::string* CreateForeignServerStmt::_internal_mutable_servername() {
  
  return servername_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateForeignServerStmt::release_servername() {
  // @@protoc_insertion_point(field_release:pg_query.CreateForeignServerStmt.servername)
  return servername_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateForeignServerStmt::set_allocated_servername(std::string* servername) {
  if (servername != nullptr) {
    
  } else {
    
  }
  servername_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), servername,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateForeignServerStmt.servername)
}

// string servertype = 2 [json_name = "servertype"];
inline void CreateForeignServerStmt::clear_servertype() {
  servertype_.ClearToEmpty();
}
inline const std::string& CreateForeignServerStmt::servertype() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.servertype)
  return _internal_servertype();
}
inline void CreateForeignServerStmt::set_servertype(const std::string& value) {
  _internal_set_servertype(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.servertype)
}
inline std::string* CreateForeignServerStmt::mutable_servertype() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignServerStmt.servertype)
  return _internal_mutable_servertype();
}
inline const std::string& CreateForeignServerStmt::_internal_servertype() const {
  return servertype_.Get();
}
inline void CreateForeignServerStmt::_internal_set_servertype(const std::string& value) {
  
  servertype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateForeignServerStmt::set_servertype(std::string&& value) {
  
  servertype_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateForeignServerStmt.servertype)
}
inline void CreateForeignServerStmt::set_servertype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  servertype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateForeignServerStmt.servertype)
}
inline void CreateForeignServerStmt::set_servertype(const char* value,
    size_t size) {
  
  servertype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateForeignServerStmt.servertype)
}
inline std::string* CreateForeignServerStmt::_internal_mutable_servertype() {
  
  return servertype_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateForeignServerStmt::release_servertype() {
  // @@protoc_insertion_point(field_release:pg_query.CreateForeignServerStmt.servertype)
  return servertype_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateForeignServerStmt::set_allocated_servertype(std::string* servertype) {
  if (servertype != nullptr) {
    
  } else {
    
  }
  servertype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), servertype,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateForeignServerStmt.servertype)
}

// string version = 3 [json_name = "version"];
inline void CreateForeignServerStmt::clear_version() {
  version_.ClearToEmpty();
}
inline const std::string& CreateForeignServerStmt::version() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.version)
  return _internal_version();
}
inline void CreateForeignServerStmt::set_version(const std::string& value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.version)
}
inline std::string* CreateForeignServerStmt::mutable_version() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignServerStmt.version)
  return _internal_mutable_version();
}
inline const std::string& CreateForeignServerStmt::_internal_version() const {
  return version_.Get();
}
inline void CreateForeignServerStmt::_internal_set_version(const std::string& value) {
  
  version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateForeignServerStmt::set_version(std::string&& value) {
  
  version_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateForeignServerStmt.version)
}
inline void CreateForeignServerStmt::set_version(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateForeignServerStmt.version)
}
inline void CreateForeignServerStmt::set_version(const char* value,
    size_t size) {
  
  version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateForeignServerStmt.version)
}
inline std::string* CreateForeignServerStmt::_internal_mutable_version() {
  
  return version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateForeignServerStmt::release_version() {
  // @@protoc_insertion_point(field_release:pg_query.CreateForeignServerStmt.version)
  return version_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateForeignServerStmt::set_allocated_version(std::string* version) {
  if (version != nullptr) {
    
  } else {
    
  }
  version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), version,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateForeignServerStmt.version)
}

// string fdwname = 4 [json_name = "fdwname"];
inline void CreateForeignServerStmt::clear_fdwname() {
  fdwname_.ClearToEmpty();
}
inline const std::string& CreateForeignServerStmt::fdwname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.fdwname)
  return _internal_fdwname();
}
inline void CreateForeignServerStmt::set_fdwname(const std::string& value) {
  _internal_set_fdwname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.fdwname)
}
inline std::string* CreateForeignServerStmt::mutable_fdwname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignServerStmt.fdwname)
  return _internal_mutable_fdwname();
}
inline const std::string& CreateForeignServerStmt::_internal_fdwname() const {
  return fdwname_.Get();
}
inline void CreateForeignServerStmt::_internal_set_fdwname(const std::string& value) {
  
  fdwname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateForeignServerStmt::set_fdwname(std::string&& value) {
  
  fdwname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateForeignServerStmt.fdwname)
}
inline void CreateForeignServerStmt::set_fdwname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  fdwname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateForeignServerStmt.fdwname)
}
inline void CreateForeignServerStmt::set_fdwname(const char* value,
    size_t size) {
  
  fdwname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateForeignServerStmt.fdwname)
}
inline std::string* CreateForeignServerStmt::_internal_mutable_fdwname() {
  
  return fdwname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateForeignServerStmt::release_fdwname() {
  // @@protoc_insertion_point(field_release:pg_query.CreateForeignServerStmt.fdwname)
  return fdwname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateForeignServerStmt::set_allocated_fdwname(std::string* fdwname) {
  if (fdwname != nullptr) {
    
  } else {
    
  }
  fdwname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fdwname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateForeignServerStmt.fdwname)
}

// bool if_not_exists = 5 [json_name = "if_not_exists"];
inline void CreateForeignServerStmt::clear_if_not_exists() {
  if_not_exists_ = false;
}
inline bool CreateForeignServerStmt::_internal_if_not_exists() const {
  return if_not_exists_;
}
inline bool CreateForeignServerStmt::if_not_exists() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.if_not_exists)
  return _internal_if_not_exists();
}
inline void CreateForeignServerStmt::_internal_set_if_not_exists(bool value) {
  
  if_not_exists_ = value;
}
inline void CreateForeignServerStmt::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.if_not_exists)
}

// repeated .pg_query.Node options = 6 [json_name = "options"];
inline int CreateForeignServerStmt::_internal_options_size() const {
  return options_.size();
}
inline int CreateForeignServerStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateForeignServerStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CreateForeignServerStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignServerStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateForeignServerStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateForeignServerStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CreateForeignServerStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CreateForeignServerStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CreateForeignServerStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CreateForeignServerStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreateForeignServerStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateForeignServerStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateForeignServerStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// AlterForeignServerStmt

// string servername = 1 [json_name = "servername"];
inline void AlterForeignServerStmt::clear_servername() {
  servername_.ClearToEmpty();
}
inline const std::string& AlterForeignServerStmt::servername() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterForeignServerStmt.servername)
  return _internal_servername();
}
inline void AlterForeignServerStmt::set_servername(const std::string& value) {
  _internal_set_servername(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterForeignServerStmt.servername)
}
inline std::string* AlterForeignServerStmt::mutable_servername() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterForeignServerStmt.servername)
  return _internal_mutable_servername();
}
inline const std::string& AlterForeignServerStmt::_internal_servername() const {
  return servername_.Get();
}
inline void AlterForeignServerStmt::_internal_set_servername(const std::string& value) {
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterForeignServerStmt::set_servername(std::string&& value) {
  
  servername_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterForeignServerStmt.servername)
}
inline void AlterForeignServerStmt::set_servername(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterForeignServerStmt.servername)
}
inline void AlterForeignServerStmt::set_servername(const char* value,
    size_t size) {
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterForeignServerStmt.servername)
}
inline std::string* AlterForeignServerStmt::_internal_mutable_servername() {
  
  return servername_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterForeignServerStmt::release_servername() {
  // @@protoc_insertion_point(field_release:pg_query.AlterForeignServerStmt.servername)
  return servername_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterForeignServerStmt::set_allocated_servername(std::string* servername) {
  if (servername != nullptr) {
    
  } else {
    
  }
  servername_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), servername,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterForeignServerStmt.servername)
}

// string version = 2 [json_name = "version"];
inline void AlterForeignServerStmt::clear_version() {
  version_.ClearToEmpty();
}
inline const std::string& AlterForeignServerStmt::version() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterForeignServerStmt.version)
  return _internal_version();
}
inline void AlterForeignServerStmt::set_version(const std::string& value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterForeignServerStmt.version)
}
inline std::string* AlterForeignServerStmt::mutable_version() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterForeignServerStmt.version)
  return _internal_mutable_version();
}
inline const std::string& AlterForeignServerStmt::_internal_version() const {
  return version_.Get();
}
inline void AlterForeignServerStmt::_internal_set_version(const std::string& value) {
  
  version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterForeignServerStmt::set_version(std::string&& value) {
  
  version_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterForeignServerStmt.version)
}
inline void AlterForeignServerStmt::set_version(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterForeignServerStmt.version)
}
inline void AlterForeignServerStmt::set_version(const char* value,
    size_t size) {
  
  version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterForeignServerStmt.version)
}
inline std::string* AlterForeignServerStmt::_internal_mutable_version() {
  
  return version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterForeignServerStmt::release_version() {
  // @@protoc_insertion_point(field_release:pg_query.AlterForeignServerStmt.version)
  return version_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterForeignServerStmt::set_allocated_version(std::string* version) {
  if (version != nullptr) {
    
  } else {
    
  }
  version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), version,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterForeignServerStmt.version)
}

// repeated .pg_query.Node options = 3 [json_name = "options"];
inline int AlterForeignServerStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterForeignServerStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterForeignServerStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterForeignServerStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterForeignServerStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterForeignServerStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterForeignServerStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterForeignServerStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterForeignServerStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterForeignServerStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterForeignServerStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterForeignServerStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterForeignServerStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterForeignServerStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterForeignServerStmt.options)
  return options_;
}

// bool has_version = 4 [json_name = "has_version"];
inline void AlterForeignServerStmt::clear_has_version() {
  has_version_ = false;
}
inline bool AlterForeignServerStmt::_internal_has_version() const {
  return has_version_;
}
inline bool AlterForeignServerStmt::has_version() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterForeignServerStmt.has_version)
  return _internal_has_version();
}
inline void AlterForeignServerStmt::_internal_set_has_version(bool value) {
  
  has_version_ = value;
}
inline void AlterForeignServerStmt::set_has_version(bool value) {
  _internal_set_has_version(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterForeignServerStmt.has_version)
}

// -------------------------------------------------------------------

// CreateUserMappingStmt

// .pg_query.RoleSpec user = 1 [json_name = "user"];
inline bool CreateUserMappingStmt::_internal_has_user() const {
  return this != internal_default_instance() && user_ != nullptr;
}
inline bool CreateUserMappingStmt::has_user() const {
  return _internal_has_user();
}
inline void CreateUserMappingStmt::clear_user() {
  if (GetArena() == nullptr && user_ != nullptr) {
    delete user_;
  }
  user_ = nullptr;
}
inline const ::pg_query::RoleSpec& CreateUserMappingStmt::_internal_user() const {
  const ::pg_query::RoleSpec* p = user_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(
      ::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& CreateUserMappingStmt::user() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateUserMappingStmt.user)
  return _internal_user();
}
inline void CreateUserMappingStmt::unsafe_arena_set_allocated_user(
    ::pg_query::RoleSpec* user) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(user_);
  }
  user_ = user;
  if (user) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateUserMappingStmt.user)
}
inline ::pg_query::RoleSpec* CreateUserMappingStmt::release_user() {
  
  ::pg_query::RoleSpec* temp = user_;
  user_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RoleSpec* CreateUserMappingStmt::unsafe_arena_release_user() {
  // @@protoc_insertion_point(field_release:pg_query.CreateUserMappingStmt.user)
  
  ::pg_query::RoleSpec* temp = user_;
  user_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* CreateUserMappingStmt::_internal_mutable_user() {
  
  if (user_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    user_ = p;
  }
  return user_;
}
inline ::pg_query::RoleSpec* CreateUserMappingStmt::mutable_user() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateUserMappingStmt.user)
  return _internal_mutable_user();
}
inline void CreateUserMappingStmt::set_allocated_user(::pg_query::RoleSpec* user) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete user_;
  }
  if (user) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(user);
    if (message_arena != submessage_arena) {
      user = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, user, submessage_arena);
    }
    
  } else {
    
  }
  user_ = user;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateUserMappingStmt.user)
}

// string servername = 2 [json_name = "servername"];
inline void CreateUserMappingStmt::clear_servername() {
  servername_.ClearToEmpty();
}
inline const std::string& CreateUserMappingStmt::servername() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateUserMappingStmt.servername)
  return _internal_servername();
}
inline void CreateUserMappingStmt::set_servername(const std::string& value) {
  _internal_set_servername(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateUserMappingStmt.servername)
}
inline std::string* CreateUserMappingStmt::mutable_servername() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateUserMappingStmt.servername)
  return _internal_mutable_servername();
}
inline const std::string& CreateUserMappingStmt::_internal_servername() const {
  return servername_.Get();
}
inline void CreateUserMappingStmt::_internal_set_servername(const std::string& value) {
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateUserMappingStmt::set_servername(std::string&& value) {
  
  servername_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateUserMappingStmt.servername)
}
inline void CreateUserMappingStmt::set_servername(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateUserMappingStmt.servername)
}
inline void CreateUserMappingStmt::set_servername(const char* value,
    size_t size) {
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateUserMappingStmt.servername)
}
inline std::string* CreateUserMappingStmt::_internal_mutable_servername() {
  
  return servername_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateUserMappingStmt::release_servername() {
  // @@protoc_insertion_point(field_release:pg_query.CreateUserMappingStmt.servername)
  return servername_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateUserMappingStmt::set_allocated_servername(std::string* servername) {
  if (servername != nullptr) {
    
  } else {
    
  }
  servername_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), servername,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateUserMappingStmt.servername)
}

// bool if_not_exists = 3 [json_name = "if_not_exists"];
inline void CreateUserMappingStmt::clear_if_not_exists() {
  if_not_exists_ = false;
}
inline bool CreateUserMappingStmt::_internal_if_not_exists() const {
  return if_not_exists_;
}
inline bool CreateUserMappingStmt::if_not_exists() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateUserMappingStmt.if_not_exists)
  return _internal_if_not_exists();
}
inline void CreateUserMappingStmt::_internal_set_if_not_exists(bool value) {
  
  if_not_exists_ = value;
}
inline void CreateUserMappingStmt::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateUserMappingStmt.if_not_exists)
}

// repeated .pg_query.Node options = 4 [json_name = "options"];
inline int CreateUserMappingStmt::_internal_options_size() const {
  return options_.size();
}
inline int CreateUserMappingStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateUserMappingStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CreateUserMappingStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateUserMappingStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateUserMappingStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateUserMappingStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CreateUserMappingStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CreateUserMappingStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateUserMappingStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CreateUserMappingStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CreateUserMappingStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreateUserMappingStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateUserMappingStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateUserMappingStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// AlterUserMappingStmt

// .pg_query.RoleSpec user = 1 [json_name = "user"];
inline bool AlterUserMappingStmt::_internal_has_user() const {
  return this != internal_default_instance() && user_ != nullptr;
}
inline bool AlterUserMappingStmt::has_user() const {
  return _internal_has_user();
}
inline void AlterUserMappingStmt::clear_user() {
  if (GetArena() == nullptr && user_ != nullptr) {
    delete user_;
  }
  user_ = nullptr;
}
inline const ::pg_query::RoleSpec& AlterUserMappingStmt::_internal_user() const {
  const ::pg_query::RoleSpec* p = user_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(
      ::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& AlterUserMappingStmt::user() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterUserMappingStmt.user)
  return _internal_user();
}
inline void AlterUserMappingStmt::unsafe_arena_set_allocated_user(
    ::pg_query::RoleSpec* user) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(user_);
  }
  user_ = user;
  if (user) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterUserMappingStmt.user)
}
inline ::pg_query::RoleSpec* AlterUserMappingStmt::release_user() {
  
  ::pg_query::RoleSpec* temp = user_;
  user_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RoleSpec* AlterUserMappingStmt::unsafe_arena_release_user() {
  // @@protoc_insertion_point(field_release:pg_query.AlterUserMappingStmt.user)
  
  ::pg_query::RoleSpec* temp = user_;
  user_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* AlterUserMappingStmt::_internal_mutable_user() {
  
  if (user_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    user_ = p;
  }
  return user_;
}
inline ::pg_query::RoleSpec* AlterUserMappingStmt::mutable_user() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterUserMappingStmt.user)
  return _internal_mutable_user();
}
inline void AlterUserMappingStmt::set_allocated_user(::pg_query::RoleSpec* user) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete user_;
  }
  if (user) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(user);
    if (message_arena != submessage_arena) {
      user = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, user, submessage_arena);
    }
    
  } else {
    
  }
  user_ = user;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterUserMappingStmt.user)
}

// string servername = 2 [json_name = "servername"];
inline void AlterUserMappingStmt::clear_servername() {
  servername_.ClearToEmpty();
}
inline const std::string& AlterUserMappingStmt::servername() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterUserMappingStmt.servername)
  return _internal_servername();
}
inline void AlterUserMappingStmt::set_servername(const std::string& value) {
  _internal_set_servername(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterUserMappingStmt.servername)
}
inline std::string* AlterUserMappingStmt::mutable_servername() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterUserMappingStmt.servername)
  return _internal_mutable_servername();
}
inline const std::string& AlterUserMappingStmt::_internal_servername() const {
  return servername_.Get();
}
inline void AlterUserMappingStmt::_internal_set_servername(const std::string& value) {
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterUserMappingStmt::set_servername(std::string&& value) {
  
  servername_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterUserMappingStmt.servername)
}
inline void AlterUserMappingStmt::set_servername(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterUserMappingStmt.servername)
}
inline void AlterUserMappingStmt::set_servername(const char* value,
    size_t size) {
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterUserMappingStmt.servername)
}
inline std::string* AlterUserMappingStmt::_internal_mutable_servername() {
  
  return servername_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterUserMappingStmt::release_servername() {
  // @@protoc_insertion_point(field_release:pg_query.AlterUserMappingStmt.servername)
  return servername_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterUserMappingStmt::set_allocated_servername(std::string* servername) {
  if (servername != nullptr) {
    
  } else {
    
  }
  servername_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), servername,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterUserMappingStmt.servername)
}

// repeated .pg_query.Node options = 3 [json_name = "options"];
inline int AlterUserMappingStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterUserMappingStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterUserMappingStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterUserMappingStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterUserMappingStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterUserMappingStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterUserMappingStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterUserMappingStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterUserMappingStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterUserMappingStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterUserMappingStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterUserMappingStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterUserMappingStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterUserMappingStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterUserMappingStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// DropUserMappingStmt

// .pg_query.RoleSpec user = 1 [json_name = "user"];
inline bool DropUserMappingStmt::_internal_has_user() const {
  return this != internal_default_instance() && user_ != nullptr;
}
inline bool DropUserMappingStmt::has_user() const {
  return _internal_has_user();
}
inline void DropUserMappingStmt::clear_user() {
  if (GetArena() == nullptr && user_ != nullptr) {
    delete user_;
  }
  user_ = nullptr;
}
inline const ::pg_query::RoleSpec& DropUserMappingStmt::_internal_user() const {
  const ::pg_query::RoleSpec* p = user_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(
      ::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& DropUserMappingStmt::user() const {
  // @@protoc_insertion_point(field_get:pg_query.DropUserMappingStmt.user)
  return _internal_user();
}
inline void DropUserMappingStmt::unsafe_arena_set_allocated_user(
    ::pg_query::RoleSpec* user) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(user_);
  }
  user_ = user;
  if (user) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DropUserMappingStmt.user)
}
inline ::pg_query::RoleSpec* DropUserMappingStmt::release_user() {
  
  ::pg_query::RoleSpec* temp = user_;
  user_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RoleSpec* DropUserMappingStmt::unsafe_arena_release_user() {
  // @@protoc_insertion_point(field_release:pg_query.DropUserMappingStmt.user)
  
  ::pg_query::RoleSpec* temp = user_;
  user_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* DropUserMappingStmt::_internal_mutable_user() {
  
  if (user_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    user_ = p;
  }
  return user_;
}
inline ::pg_query::RoleSpec* DropUserMappingStmt::mutable_user() {
  // @@protoc_insertion_point(field_mutable:pg_query.DropUserMappingStmt.user)
  return _internal_mutable_user();
}
inline void DropUserMappingStmt::set_allocated_user(::pg_query::RoleSpec* user) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete user_;
  }
  if (user) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(user);
    if (message_arena != submessage_arena) {
      user = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, user, submessage_arena);
    }
    
  } else {
    
  }
  user_ = user;
  // @@protoc_insertion_point(field_set_allocated:pg_query.DropUserMappingStmt.user)
}

// string servername = 2 [json_name = "servername"];
inline void DropUserMappingStmt::clear_servername() {
  servername_.ClearToEmpty();
}
inline const std::string& DropUserMappingStmt::servername() const {
  // @@protoc_insertion_point(field_get:pg_query.DropUserMappingStmt.servername)
  return _internal_servername();
}
inline void DropUserMappingStmt::set_servername(const std::string& value) {
  _internal_set_servername(value);
  // @@protoc_insertion_point(field_set:pg_query.DropUserMappingStmt.servername)
}
inline std::string* DropUserMappingStmt::mutable_servername() {
  // @@protoc_insertion_point(field_mutable:pg_query.DropUserMappingStmt.servername)
  return _internal_mutable_servername();
}
inline const std::string& DropUserMappingStmt::_internal_servername() const {
  return servername_.Get();
}
inline void DropUserMappingStmt::_internal_set_servername(const std::string& value) {
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void DropUserMappingStmt::set_servername(std::string&& value) {
  
  servername_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.DropUserMappingStmt.servername)
}
inline void DropUserMappingStmt::set_servername(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.DropUserMappingStmt.servername)
}
inline void DropUserMappingStmt::set_servername(const char* value,
    size_t size) {
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.DropUserMappingStmt.servername)
}
inline std::string* DropUserMappingStmt::_internal_mutable_servername() {
  
  return servername_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* DropUserMappingStmt::release_servername() {
  // @@protoc_insertion_point(field_release:pg_query.DropUserMappingStmt.servername)
  return servername_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void DropUserMappingStmt::set_allocated_servername(std::string* servername) {
  if (servername != nullptr) {
    
  } else {
    
  }
  servername_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), servername,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.DropUserMappingStmt.servername)
}

// bool missing_ok = 3 [json_name = "missing_ok"];
inline void DropUserMappingStmt::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool DropUserMappingStmt::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool DropUserMappingStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.DropUserMappingStmt.missing_ok)
  return _internal_missing_ok();
}
inline void DropUserMappingStmt::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void DropUserMappingStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.DropUserMappingStmt.missing_ok)
}

// -------------------------------------------------------------------

// AlterTableSpaceOptionsStmt

// string tablespacename = 1 [json_name = "tablespacename"];
inline void AlterTableSpaceOptionsStmt::clear_tablespacename() {
  tablespacename_.ClearToEmpty();
}
inline const std::string& AlterTableSpaceOptionsStmt::tablespacename() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableSpaceOptionsStmt.tablespacename)
  return _internal_tablespacename();
}
inline void AlterTableSpaceOptionsStmt::set_tablespacename(const std::string& value) {
  _internal_set_tablespacename(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableSpaceOptionsStmt.tablespacename)
}
inline std::string* AlterTableSpaceOptionsStmt::mutable_tablespacename() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableSpaceOptionsStmt.tablespacename)
  return _internal_mutable_tablespacename();
}
inline const std::string& AlterTableSpaceOptionsStmt::_internal_tablespacename() const {
  return tablespacename_.Get();
}
inline void AlterTableSpaceOptionsStmt::_internal_set_tablespacename(const std::string& value) {
  
  tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterTableSpaceOptionsStmt::set_tablespacename(std::string&& value) {
  
  tablespacename_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterTableSpaceOptionsStmt.tablespacename)
}
inline void AlterTableSpaceOptionsStmt::set_tablespacename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterTableSpaceOptionsStmt.tablespacename)
}
inline void AlterTableSpaceOptionsStmt::set_tablespacename(const char* value,
    size_t size) {
  
  tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterTableSpaceOptionsStmt.tablespacename)
}
inline std::string* AlterTableSpaceOptionsStmt::_internal_mutable_tablespacename() {
  
  return tablespacename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterTableSpaceOptionsStmt::release_tablespacename() {
  // @@protoc_insertion_point(field_release:pg_query.AlterTableSpaceOptionsStmt.tablespacename)
  return tablespacename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterTableSpaceOptionsStmt::set_allocated_tablespacename(std::string* tablespacename) {
  if (tablespacename != nullptr) {
    
  } else {
    
  }
  tablespacename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tablespacename,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableSpaceOptionsStmt.tablespacename)
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int AlterTableSpaceOptionsStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterTableSpaceOptionsStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterTableSpaceOptionsStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterTableSpaceOptionsStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableSpaceOptionsStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterTableSpaceOptionsStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTableSpaceOptionsStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterTableSpaceOptionsStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterTableSpaceOptionsStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableSpaceOptionsStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterTableSpaceOptionsStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterTableSpaceOptionsStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterTableSpaceOptionsStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterTableSpaceOptionsStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterTableSpaceOptionsStmt.options)
  return options_;
}

// bool is_reset = 3 [json_name = "isReset"];
inline void AlterTableSpaceOptionsStmt::clear_is_reset() {
  is_reset_ = false;
}
inline bool AlterTableSpaceOptionsStmt::_internal_is_reset() const {
  return is_reset_;
}
inline bool AlterTableSpaceOptionsStmt::is_reset() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableSpaceOptionsStmt.is_reset)
  return _internal_is_reset();
}
inline void AlterTableSpaceOptionsStmt::_internal_set_is_reset(bool value) {
  
  is_reset_ = value;
}
inline void AlterTableSpaceOptionsStmt::set_is_reset(bool value) {
  _internal_set_is_reset(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableSpaceOptionsStmt.is_reset)
}

// -------------------------------------------------------------------

// AlterTableMoveAllStmt

// string orig_tablespacename = 1 [json_name = "orig_tablespacename"];
inline void AlterTableMoveAllStmt::clear_orig_tablespacename() {
  orig_tablespacename_.ClearToEmpty();
}
inline const std::string& AlterTableMoveAllStmt::orig_tablespacename() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.orig_tablespacename)
  return _internal_orig_tablespacename();
}
inline void AlterTableMoveAllStmt::set_orig_tablespacename(const std::string& value) {
  _internal_set_orig_tablespacename(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableMoveAllStmt.orig_tablespacename)
}
inline std::string* AlterTableMoveAllStmt::mutable_orig_tablespacename() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableMoveAllStmt.orig_tablespacename)
  return _internal_mutable_orig_tablespacename();
}
inline const std::string& AlterTableMoveAllStmt::_internal_orig_tablespacename() const {
  return orig_tablespacename_.Get();
}
inline void AlterTableMoveAllStmt::_internal_set_orig_tablespacename(const std::string& value) {
  
  orig_tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterTableMoveAllStmt::set_orig_tablespacename(std::string&& value) {
  
  orig_tablespacename_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterTableMoveAllStmt.orig_tablespacename)
}
inline void AlterTableMoveAllStmt::set_orig_tablespacename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  orig_tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterTableMoveAllStmt.orig_tablespacename)
}
inline void AlterTableMoveAllStmt::set_orig_tablespacename(const char* value,
    size_t size) {
  
  orig_tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterTableMoveAllStmt.orig_tablespacename)
}
inline std::string* AlterTableMoveAllStmt::_internal_mutable_orig_tablespacename() {
  
  return orig_tablespacename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterTableMoveAllStmt::release_orig_tablespacename() {
  // @@protoc_insertion_point(field_release:pg_query.AlterTableMoveAllStmt.orig_tablespacename)
  return orig_tablespacename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterTableMoveAllStmt::set_allocated_orig_tablespacename(std::string* orig_tablespacename) {
  if (orig_tablespacename != nullptr) {
    
  } else {
    
  }
  orig_tablespacename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), orig_tablespacename,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableMoveAllStmt.orig_tablespacename)
}

// .pg_query.ObjectType objtype = 2 [json_name = "objtype"];
inline void AlterTableMoveAllStmt::clear_objtype() {
  objtype_ = 0;
}
inline ::pg_query::ObjectType AlterTableMoveAllStmt::_internal_objtype() const {
  return static_cast< ::pg_query::ObjectType >(objtype_);
}
inline ::pg_query::ObjectType AlterTableMoveAllStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.objtype)
  return _internal_objtype();
}
inline void AlterTableMoveAllStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  
  objtype_ = value;
}
inline void AlterTableMoveAllStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableMoveAllStmt.objtype)
}

// repeated .pg_query.Node roles = 3 [json_name = "roles"];
inline int AlterTableMoveAllStmt::_internal_roles_size() const {
  return roles_.size();
}
inline int AlterTableMoveAllStmt::roles_size() const {
  return _internal_roles_size();
}
inline void AlterTableMoveAllStmt::clear_roles() {
  roles_.Clear();
}
inline ::pg_query::Node* AlterTableMoveAllStmt::mutable_roles(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableMoveAllStmt.roles)
  return roles_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterTableMoveAllStmt::mutable_roles() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTableMoveAllStmt.roles)
  return &roles_;
}
inline const ::pg_query::Node& AlterTableMoveAllStmt::_internal_roles(int index) const {
  return roles_.Get(index);
}
inline const ::pg_query::Node& AlterTableMoveAllStmt::roles(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.roles)
  return _internal_roles(index);
}
inline ::pg_query::Node* AlterTableMoveAllStmt::_internal_add_roles() {
  return roles_.Add();
}
inline ::pg_query::Node* AlterTableMoveAllStmt::add_roles() {
  // @@protoc_insertion_point(field_add:pg_query.AlterTableMoveAllStmt.roles)
  return _internal_add_roles();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterTableMoveAllStmt::roles() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterTableMoveAllStmt.roles)
  return roles_;
}

// string new_tablespacename = 4 [json_name = "new_tablespacename"];
inline void AlterTableMoveAllStmt::clear_new_tablespacename() {
  new_tablespacename_.ClearToEmpty();
}
inline const std::string& AlterTableMoveAllStmt::new_tablespacename() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.new_tablespacename)
  return _internal_new_tablespacename();
}
inline void AlterTableMoveAllStmt::set_new_tablespacename(const std::string& value) {
  _internal_set_new_tablespacename(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableMoveAllStmt.new_tablespacename)
}
inline std::string* AlterTableMoveAllStmt::mutable_new_tablespacename() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableMoveAllStmt.new_tablespacename)
  return _internal_mutable_new_tablespacename();
}
inline const std::string& AlterTableMoveAllStmt::_internal_new_tablespacename() const {
  return new_tablespacename_.Get();
}
inline void AlterTableMoveAllStmt::_internal_set_new_tablespacename(const std::string& value) {
  
  new_tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterTableMoveAllStmt::set_new_tablespacename(std::string&& value) {
  
  new_tablespacename_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterTableMoveAllStmt.new_tablespacename)
}
inline void AlterTableMoveAllStmt::set_new_tablespacename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  new_tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterTableMoveAllStmt.new_tablespacename)
}
inline void AlterTableMoveAllStmt::set_new_tablespacename(const char* value,
    size_t size) {
  
  new_tablespacename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterTableMoveAllStmt.new_tablespacename)
}
inline std::string* AlterTableMoveAllStmt::_internal_mutable_new_tablespacename() {
  
  return new_tablespacename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterTableMoveAllStmt::release_new_tablespacename() {
  // @@protoc_insertion_point(field_release:pg_query.AlterTableMoveAllStmt.new_tablespacename)
  return new_tablespacename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterTableMoveAllStmt::set_allocated_new_tablespacename(std::string* new_tablespacename) {
  if (new_tablespacename != nullptr) {
    
  } else {
    
  }
  new_tablespacename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), new_tablespacename,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableMoveAllStmt.new_tablespacename)
}

// bool nowait = 5 [json_name = "nowait"];
inline void AlterTableMoveAllStmt::clear_nowait() {
  nowait_ = false;
}
inline bool AlterTableMoveAllStmt::_internal_nowait() const {
  return nowait_;
}
inline bool AlterTableMoveAllStmt::nowait() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.nowait)
  return _internal_nowait();
}
inline void AlterTableMoveAllStmt::_internal_set_nowait(bool value) {
  
  nowait_ = value;
}
inline void AlterTableMoveAllStmt::set_nowait(bool value) {
  _internal_set_nowait(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableMoveAllStmt.nowait)
}

// -------------------------------------------------------------------

// SecLabelStmt

// .pg_query.ObjectType objtype = 1 [json_name = "objtype"];
inline void SecLabelStmt::clear_objtype() {
  objtype_ = 0;
}
inline ::pg_query::ObjectType SecLabelStmt::_internal_objtype() const {
  return static_cast< ::pg_query::ObjectType >(objtype_);
}
inline ::pg_query::ObjectType SecLabelStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.SecLabelStmt.objtype)
  return _internal_objtype();
}
inline void SecLabelStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  
  objtype_ = value;
}
inline void SecLabelStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.SecLabelStmt.objtype)
}

// .pg_query.Node object = 2 [json_name = "object"];
inline bool SecLabelStmt::_internal_has_object() const {
  return this != internal_default_instance() && object_ != nullptr;
}
inline bool SecLabelStmt::has_object() const {
  return _internal_has_object();
}
inline void SecLabelStmt::clear_object() {
  if (GetArena() == nullptr && object_ != nullptr) {
    delete object_;
  }
  object_ = nullptr;
}
inline const ::pg_query::Node& SecLabelStmt::_internal_object() const {
  const ::pg_query::Node* p = object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SecLabelStmt::object() const {
  // @@protoc_insertion_point(field_get:pg_query.SecLabelStmt.object)
  return _internal_object();
}
inline void SecLabelStmt::unsafe_arena_set_allocated_object(
    ::pg_query::Node* object) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(object_);
  }
  object_ = object;
  if (object) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SecLabelStmt.object)
}
inline ::pg_query::Node* SecLabelStmt::release_object() {
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SecLabelStmt::unsafe_arena_release_object() {
  // @@protoc_insertion_point(field_release:pg_query.SecLabelStmt.object)
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SecLabelStmt::_internal_mutable_object() {
  
  if (object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    object_ = p;
  }
  return object_;
}
inline ::pg_query::Node* SecLabelStmt::mutable_object() {
  // @@protoc_insertion_point(field_mutable:pg_query.SecLabelStmt.object)
  return _internal_mutable_object();
}
inline void SecLabelStmt::set_allocated_object(::pg_query::Node* object) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete object_;
  }
  if (object) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(object);
    if (message_arena != submessage_arena) {
      object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, object, submessage_arena);
    }
    
  } else {
    
  }
  object_ = object;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SecLabelStmt.object)
}

// string provider = 3 [json_name = "provider"];
inline void SecLabelStmt::clear_provider() {
  provider_.ClearToEmpty();
}
inline const std::string& SecLabelStmt::provider() const {
  // @@protoc_insertion_point(field_get:pg_query.SecLabelStmt.provider)
  return _internal_provider();
}
inline void SecLabelStmt::set_provider(const std::string& value) {
  _internal_set_provider(value);
  // @@protoc_insertion_point(field_set:pg_query.SecLabelStmt.provider)
}
inline std::string* SecLabelStmt::mutable_provider() {
  // @@protoc_insertion_point(field_mutable:pg_query.SecLabelStmt.provider)
  return _internal_mutable_provider();
}
inline const std::string& SecLabelStmt::_internal_provider() const {
  return provider_.Get();
}
inline void SecLabelStmt::_internal_set_provider(const std::string& value) {
  
  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SecLabelStmt::set_provider(std::string&& value) {
  
  provider_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.SecLabelStmt.provider)
}
inline void SecLabelStmt::set_provider(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.SecLabelStmt.provider)
}
inline void SecLabelStmt::set_provider(const char* value,
    size_t size) {
  
  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.SecLabelStmt.provider)
}
inline std::string* SecLabelStmt::_internal_mutable_provider() {
  
  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SecLabelStmt::release_provider() {
  // @@protoc_insertion_point(field_release:pg_query.SecLabelStmt.provider)
  return provider_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SecLabelStmt::set_allocated_provider(std::string* provider) {
  if (provider != nullptr) {
    
  } else {
    
  }
  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.SecLabelStmt.provider)
}

// string label = 4 [json_name = "label"];
inline void SecLabelStmt::clear_label() {
  label_.ClearToEmpty();
}
inline const std::string& SecLabelStmt::label() const {
  // @@protoc_insertion_point(field_get:pg_query.SecLabelStmt.label)
  return _internal_label();
}
inline void SecLabelStmt::set_label(const std::string& value) {
  _internal_set_label(value);
  // @@protoc_insertion_point(field_set:pg_query.SecLabelStmt.label)
}
inline std::string* SecLabelStmt::mutable_label() {
  // @@protoc_insertion_point(field_mutable:pg_query.SecLabelStmt.label)
  return _internal_mutable_label();
}
inline const std::string& SecLabelStmt::_internal_label() const {
  return label_.Get();
}
inline void SecLabelStmt::_internal_set_label(const std::string& value) {
  
  label_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SecLabelStmt::set_label(std::string&& value) {
  
  label_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.SecLabelStmt.label)
}
inline void SecLabelStmt::set_label(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  label_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.SecLabelStmt.label)
}
inline void SecLabelStmt::set_label(const char* value,
    size_t size) {
  
  label_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.SecLabelStmt.label)
}
inline std::string* SecLabelStmt::_internal_mutable_label() {
  
  return label_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SecLabelStmt::release_label() {
  // @@protoc_insertion_point(field_release:pg_query.SecLabelStmt.label)
  return label_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SecLabelStmt::set_allocated_label(std::string* label) {
  if (label != nullptr) {
    
  } else {
    
  }
  label_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), label,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.SecLabelStmt.label)
}

// -------------------------------------------------------------------

// CreateForeignTableStmt

// .pg_query.CreateStmt base_stmt = 1 [json_name = "base"];
inline bool CreateForeignTableStmt::_internal_has_base_stmt() const {
  return this != internal_default_instance() && base_stmt_ != nullptr;
}
inline bool CreateForeignTableStmt::has_base_stmt() const {
  return _internal_has_base_stmt();
}
inline void CreateForeignTableStmt::clear_base_stmt() {
  if (GetArena() == nullptr && base_stmt_ != nullptr) {
    delete base_stmt_;
  }
  base_stmt_ = nullptr;
}
inline const ::pg_query::CreateStmt& CreateForeignTableStmt::_internal_base_stmt() const {
  const ::pg_query::CreateStmt* p = base_stmt_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::CreateStmt&>(
      ::pg_query::_CreateStmt_default_instance_);
}
inline const ::pg_query::CreateStmt& CreateForeignTableStmt::base_stmt() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignTableStmt.base_stmt)
  return _internal_base_stmt();
}
inline void CreateForeignTableStmt::unsafe_arena_set_allocated_base_stmt(
    ::pg_query::CreateStmt* base_stmt) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_stmt_);
  }
  base_stmt_ = base_stmt;
  if (base_stmt) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateForeignTableStmt.base_stmt)
}
inline ::pg_query::CreateStmt* CreateForeignTableStmt::release_base_stmt() {
  
  ::pg_query::CreateStmt* temp = base_stmt_;
  base_stmt_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::CreateStmt* CreateForeignTableStmt::unsafe_arena_release_base_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.CreateForeignTableStmt.base_stmt)
  
  ::pg_query::CreateStmt* temp = base_stmt_;
  base_stmt_ = nullptr;
  return temp;
}
inline ::pg_query::CreateStmt* CreateForeignTableStmt::_internal_mutable_base_stmt() {
  
  if (base_stmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::CreateStmt>(GetArena());
    base_stmt_ = p;
  }
  return base_stmt_;
}
inline ::pg_query::CreateStmt* CreateForeignTableStmt::mutable_base_stmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignTableStmt.base_stmt)
  return _internal_mutable_base_stmt();
}
inline void CreateForeignTableStmt::set_allocated_base_stmt(::pg_query::CreateStmt* base_stmt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete base_stmt_;
  }
  if (base_stmt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(base_stmt);
    if (message_arena != submessage_arena) {
      base_stmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, base_stmt, submessage_arena);
    }
    
  } else {
    
  }
  base_stmt_ = base_stmt;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateForeignTableStmt.base_stmt)
}

// string servername = 2 [json_name = "servername"];
inline void CreateForeignTableStmt::clear_servername() {
  servername_.ClearToEmpty();
}
inline const std::string& CreateForeignTableStmt::servername() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignTableStmt.servername)
  return _internal_servername();
}
inline void CreateForeignTableStmt::set_servername(const std::string& value) {
  _internal_set_servername(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateForeignTableStmt.servername)
}
inline std::string* CreateForeignTableStmt::mutable_servername() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignTableStmt.servername)
  return _internal_mutable_servername();
}
inline const std::string& CreateForeignTableStmt::_internal_servername() const {
  return servername_.Get();
}
inline void CreateForeignTableStmt::_internal_set_servername(const std::string& value) {
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateForeignTableStmt::set_servername(std::string&& value) {
  
  servername_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateForeignTableStmt.servername)
}
inline void CreateForeignTableStmt::set_servername(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateForeignTableStmt.servername)
}
inline void CreateForeignTableStmt::set_servername(const char* value,
    size_t size) {
  
  servername_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateForeignTableStmt.servername)
}
inline std::string* CreateForeignTableStmt::_internal_mutable_servername() {
  
  return servername_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateForeignTableStmt::release_servername() {
  // @@protoc_insertion_point(field_release:pg_query.CreateForeignTableStmt.servername)
  return servername_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateForeignTableStmt::set_allocated_servername(std::string* servername) {
  if (servername != nullptr) {
    
  } else {
    
  }
  servername_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), servername,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateForeignTableStmt.servername)
}

// repeated .pg_query.Node options = 3 [json_name = "options"];
inline int CreateForeignTableStmt::_internal_options_size() const {
  return options_.size();
}
inline int CreateForeignTableStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateForeignTableStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CreateForeignTableStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignTableStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateForeignTableStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateForeignTableStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CreateForeignTableStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CreateForeignTableStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignTableStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CreateForeignTableStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CreateForeignTableStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreateForeignTableStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateForeignTableStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateForeignTableStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// ImportForeignSchemaStmt

// string server_name = 1 [json_name = "server_name"];
inline void ImportForeignSchemaStmt::clear_server_name() {
  server_name_.ClearToEmpty();
}
inline const std::string& ImportForeignSchemaStmt::server_name() const {
  // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.server_name)
  return _internal_server_name();
}
inline void ImportForeignSchemaStmt::set_server_name(const std::string& value) {
  _internal_set_server_name(value);
  // @@protoc_insertion_point(field_set:pg_query.ImportForeignSchemaStmt.server_name)
}
inline std::string* ImportForeignSchemaStmt::mutable_server_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.ImportForeignSchemaStmt.server_name)
  return _internal_mutable_server_name();
}
inline const std::string& ImportForeignSchemaStmt::_internal_server_name() const {
  return server_name_.Get();
}
inline void ImportForeignSchemaStmt::_internal_set_server_name(const std::string& value) {
  
  server_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ImportForeignSchemaStmt::set_server_name(std::string&& value) {
  
  server_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ImportForeignSchemaStmt.server_name)
}
inline void ImportForeignSchemaStmt::set_server_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  server_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ImportForeignSchemaStmt.server_name)
}
inline void ImportForeignSchemaStmt::set_server_name(const char* value,
    size_t size) {
  
  server_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ImportForeignSchemaStmt.server_name)
}
inline std::string* ImportForeignSchemaStmt::_internal_mutable_server_name() {
  
  return server_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ImportForeignSchemaStmt::release_server_name() {
  // @@protoc_insertion_point(field_release:pg_query.ImportForeignSchemaStmt.server_name)
  return server_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ImportForeignSchemaStmt::set_allocated_server_name(std::string* server_name) {
  if (server_name != nullptr) {
    
  } else {
    
  }
  server_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), server_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ImportForeignSchemaStmt.server_name)
}

// string remote_schema = 2 [json_name = "remote_schema"];
inline void ImportForeignSchemaStmt::clear_remote_schema() {
  remote_schema_.ClearToEmpty();
}
inline const std::string& ImportForeignSchemaStmt::remote_schema() const {
  // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.remote_schema)
  return _internal_remote_schema();
}
inline void ImportForeignSchemaStmt::set_remote_schema(const std::string& value) {
  _internal_set_remote_schema(value);
  // @@protoc_insertion_point(field_set:pg_query.ImportForeignSchemaStmt.remote_schema)
}
inline std::string* ImportForeignSchemaStmt::mutable_remote_schema() {
  // @@protoc_insertion_point(field_mutable:pg_query.ImportForeignSchemaStmt.remote_schema)
  return _internal_mutable_remote_schema();
}
inline const std::string& ImportForeignSchemaStmt::_internal_remote_schema() const {
  return remote_schema_.Get();
}
inline void ImportForeignSchemaStmt::_internal_set_remote_schema(const std::string& value) {
  
  remote_schema_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ImportForeignSchemaStmt::set_remote_schema(std::string&& value) {
  
  remote_schema_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ImportForeignSchemaStmt.remote_schema)
}
inline void ImportForeignSchemaStmt::set_remote_schema(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  remote_schema_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ImportForeignSchemaStmt.remote_schema)
}
inline void ImportForeignSchemaStmt::set_remote_schema(const char* value,
    size_t size) {
  
  remote_schema_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ImportForeignSchemaStmt.remote_schema)
}
inline std::string* ImportForeignSchemaStmt::_internal_mutable_remote_schema() {
  
  return remote_schema_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ImportForeignSchemaStmt::release_remote_schema() {
  // @@protoc_insertion_point(field_release:pg_query.ImportForeignSchemaStmt.remote_schema)
  return remote_schema_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ImportForeignSchemaStmt::set_allocated_remote_schema(std::string* remote_schema) {
  if (remote_schema != nullptr) {
    
  } else {
    
  }
  remote_schema_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), remote_schema,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ImportForeignSchemaStmt.remote_schema)
}

// string local_schema = 3 [json_name = "local_schema"];
inline void ImportForeignSchemaStmt::clear_local_schema() {
  local_schema_.ClearToEmpty();
}
inline const std::string& ImportForeignSchemaStmt::local_schema() const {
  // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.local_schema)
  return _internal_local_schema();
}
inline void ImportForeignSchemaStmt::set_local_schema(const std::string& value) {
  _internal_set_local_schema(value);
  // @@protoc_insertion_point(field_set:pg_query.ImportForeignSchemaStmt.local_schema)
}
inline std::string* ImportForeignSchemaStmt::mutable_local_schema() {
  // @@protoc_insertion_point(field_mutable:pg_query.ImportForeignSchemaStmt.local_schema)
  return _internal_mutable_local_schema();
}
inline const std::string& ImportForeignSchemaStmt::_internal_local_schema() const {
  return local_schema_.Get();
}
inline void ImportForeignSchemaStmt::_internal_set_local_schema(const std::string& value) {
  
  local_schema_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ImportForeignSchemaStmt::set_local_schema(std::string&& value) {
  
  local_schema_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ImportForeignSchemaStmt.local_schema)
}
inline void ImportForeignSchemaStmt::set_local_schema(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  local_schema_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ImportForeignSchemaStmt.local_schema)
}
inline void ImportForeignSchemaStmt::set_local_schema(const char* value,
    size_t size) {
  
  local_schema_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ImportForeignSchemaStmt.local_schema)
}
inline std::string* ImportForeignSchemaStmt::_internal_mutable_local_schema() {
  
  return local_schema_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ImportForeignSchemaStmt::release_local_schema() {
  // @@protoc_insertion_point(field_release:pg_query.ImportForeignSchemaStmt.local_schema)
  return local_schema_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ImportForeignSchemaStmt::set_allocated_local_schema(std::string* local_schema) {
  if (local_schema != nullptr) {
    
  } else {
    
  }
  local_schema_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), local_schema,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ImportForeignSchemaStmt.local_schema)
}

// .pg_query.ImportForeignSchemaType list_type = 4 [json_name = "list_type"];
inline void ImportForeignSchemaStmt::clear_list_type() {
  list_type_ = 0;
}
inline ::pg_query::ImportForeignSchemaType ImportForeignSchemaStmt::_internal_list_type() const {
  return static_cast< ::pg_query::ImportForeignSchemaType >(list_type_);
}
inline ::pg_query::ImportForeignSchemaType ImportForeignSchemaStmt::list_type() const {
  // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.list_type)
  return _internal_list_type();
}
inline void ImportForeignSchemaStmt::_internal_set_list_type(::pg_query::ImportForeignSchemaType value) {
  
  list_type_ = value;
}
inline void ImportForeignSchemaStmt::set_list_type(::pg_query::ImportForeignSchemaType value) {
  _internal_set_list_type(value);
  // @@protoc_insertion_point(field_set:pg_query.ImportForeignSchemaStmt.list_type)
}

// repeated .pg_query.Node table_list = 5 [json_name = "table_list"];
inline int ImportForeignSchemaStmt::_internal_table_list_size() const {
  return table_list_.size();
}
inline int ImportForeignSchemaStmt::table_list_size() const {
  return _internal_table_list_size();
}
inline void ImportForeignSchemaStmt::clear_table_list() {
  table_list_.Clear();
}
inline ::pg_query::Node* ImportForeignSchemaStmt::mutable_table_list(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ImportForeignSchemaStmt.table_list)
  return table_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ImportForeignSchemaStmt::mutable_table_list() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ImportForeignSchemaStmt.table_list)
  return &table_list_;
}
inline const ::pg_query::Node& ImportForeignSchemaStmt::_internal_table_list(int index) const {
  return table_list_.Get(index);
}
inline const ::pg_query::Node& ImportForeignSchemaStmt::table_list(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.table_list)
  return _internal_table_list(index);
}
inline ::pg_query::Node* ImportForeignSchemaStmt::_internal_add_table_list() {
  return table_list_.Add();
}
inline ::pg_query::Node* ImportForeignSchemaStmt::add_table_list() {
  // @@protoc_insertion_point(field_add:pg_query.ImportForeignSchemaStmt.table_list)
  return _internal_add_table_list();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ImportForeignSchemaStmt::table_list() const {
  // @@protoc_insertion_point(field_list:pg_query.ImportForeignSchemaStmt.table_list)
  return table_list_;
}

// repeated .pg_query.Node options = 6 [json_name = "options"];
inline int ImportForeignSchemaStmt::_internal_options_size() const {
  return options_.size();
}
inline int ImportForeignSchemaStmt::options_size() const {
  return _internal_options_size();
}
inline void ImportForeignSchemaStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* ImportForeignSchemaStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ImportForeignSchemaStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ImportForeignSchemaStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ImportForeignSchemaStmt.options)
  return &options_;
}
inline const ::pg_query::Node& ImportForeignSchemaStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& ImportForeignSchemaStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* ImportForeignSchemaStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* ImportForeignSchemaStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.ImportForeignSchemaStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ImportForeignSchemaStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.ImportForeignSchemaStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// CreateExtensionStmt

// string extname = 1 [json_name = "extname"];
inline void CreateExtensionStmt::clear_extname() {
  extname_.ClearToEmpty();
}
inline const std::string& CreateExtensionStmt::extname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateExtensionStmt.extname)
  return _internal_extname();
}
inline void CreateExtensionStmt::set_extname(const std::string& value) {
  _internal_set_extname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateExtensionStmt.extname)
}
inline std::string* CreateExtensionStmt::mutable_extname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateExtensionStmt.extname)
  return _internal_mutable_extname();
}
inline const std::string& CreateExtensionStmt::_internal_extname() const {
  return extname_.Get();
}
inline void CreateExtensionStmt::_internal_set_extname(const std::string& value) {
  
  extname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateExtensionStmt::set_extname(std::string&& value) {
  
  extname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateExtensionStmt.extname)
}
inline void CreateExtensionStmt::set_extname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  extname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateExtensionStmt.extname)
}
inline void CreateExtensionStmt::set_extname(const char* value,
    size_t size) {
  
  extname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateExtensionStmt.extname)
}
inline std::string* CreateExtensionStmt::_internal_mutable_extname() {
  
  return extname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateExtensionStmt::release_extname() {
  // @@protoc_insertion_point(field_release:pg_query.CreateExtensionStmt.extname)
  return extname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateExtensionStmt::set_allocated_extname(std::string* extname) {
  if (extname != nullptr) {
    
  } else {
    
  }
  extname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), extname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateExtensionStmt.extname)
}

// bool if_not_exists = 2 [json_name = "if_not_exists"];
inline void CreateExtensionStmt::clear_if_not_exists() {
  if_not_exists_ = false;
}
inline bool CreateExtensionStmt::_internal_if_not_exists() const {
  return if_not_exists_;
}
inline bool CreateExtensionStmt::if_not_exists() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateExtensionStmt.if_not_exists)
  return _internal_if_not_exists();
}
inline void CreateExtensionStmt::_internal_set_if_not_exists(bool value) {
  
  if_not_exists_ = value;
}
inline void CreateExtensionStmt::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateExtensionStmt.if_not_exists)
}

// repeated .pg_query.Node options = 3 [json_name = "options"];
inline int CreateExtensionStmt::_internal_options_size() const {
  return options_.size();
}
inline int CreateExtensionStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateExtensionStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CreateExtensionStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateExtensionStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateExtensionStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateExtensionStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CreateExtensionStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CreateExtensionStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateExtensionStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CreateExtensionStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CreateExtensionStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreateExtensionStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateExtensionStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateExtensionStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// AlterExtensionStmt

// string extname = 1 [json_name = "extname"];
inline void AlterExtensionStmt::clear_extname() {
  extname_.ClearToEmpty();
}
inline const std::string& AlterExtensionStmt::extname() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterExtensionStmt.extname)
  return _internal_extname();
}
inline void AlterExtensionStmt::set_extname(const std::string& value) {
  _internal_set_extname(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterExtensionStmt.extname)
}
inline std::string* AlterExtensionStmt::mutable_extname() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterExtensionStmt.extname)
  return _internal_mutable_extname();
}
inline const std::string& AlterExtensionStmt::_internal_extname() const {
  return extname_.Get();
}
inline void AlterExtensionStmt::_internal_set_extname(const std::string& value) {
  
  extname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterExtensionStmt::set_extname(std::string&& value) {
  
  extname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterExtensionStmt.extname)
}
inline void AlterExtensionStmt::set_extname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  extname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterExtensionStmt.extname)
}
inline void AlterExtensionStmt::set_extname(const char* value,
    size_t size) {
  
  extname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterExtensionStmt.extname)
}
inline std::string* AlterExtensionStmt::_internal_mutable_extname() {
  
  return extname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterExtensionStmt::release_extname() {
  // @@protoc_insertion_point(field_release:pg_query.AlterExtensionStmt.extname)
  return extname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterExtensionStmt::set_allocated_extname(std::string* extname) {
  if (extname != nullptr) {
    
  } else {
    
  }
  extname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), extname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterExtensionStmt.extname)
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int AlterExtensionStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterExtensionStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterExtensionStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterExtensionStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterExtensionStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterExtensionStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterExtensionStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterExtensionStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterExtensionStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterExtensionStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterExtensionStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterExtensionStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterExtensionStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterExtensionStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterExtensionStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// AlterExtensionContentsStmt

// string extname = 1 [json_name = "extname"];
inline void AlterExtensionContentsStmt::clear_extname() {
  extname_.ClearToEmpty();
}
inline const std::string& AlterExtensionContentsStmt::extname() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterExtensionContentsStmt.extname)
  return _internal_extname();
}
inline void AlterExtensionContentsStmt::set_extname(const std::string& value) {
  _internal_set_extname(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterExtensionContentsStmt.extname)
}
inline std::string* AlterExtensionContentsStmt::mutable_extname() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterExtensionContentsStmt.extname)
  return _internal_mutable_extname();
}
inline const std::string& AlterExtensionContentsStmt::_internal_extname() const {
  return extname_.Get();
}
inline void AlterExtensionContentsStmt::_internal_set_extname(const std::string& value) {
  
  extname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterExtensionContentsStmt::set_extname(std::string&& value) {
  
  extname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterExtensionContentsStmt.extname)
}
inline void AlterExtensionContentsStmt::set_extname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  extname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterExtensionContentsStmt.extname)
}
inline void AlterExtensionContentsStmt::set_extname(const char* value,
    size_t size) {
  
  extname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterExtensionContentsStmt.extname)
}
inline std::string* AlterExtensionContentsStmt::_internal_mutable_extname() {
  
  return extname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterExtensionContentsStmt::release_extname() {
  // @@protoc_insertion_point(field_release:pg_query.AlterExtensionContentsStmt.extname)
  return extname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterExtensionContentsStmt::set_allocated_extname(std::string* extname) {
  if (extname != nullptr) {
    
  } else {
    
  }
  extname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), extname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterExtensionContentsStmt.extname)
}

// int32 action = 2 [json_name = "action"];
inline void AlterExtensionContentsStmt::clear_action() {
  action_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 AlterExtensionContentsStmt::_internal_action() const {
  return action_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 AlterExtensionContentsStmt::action() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterExtensionContentsStmt.action)
  return _internal_action();
}
inline void AlterExtensionContentsStmt::_internal_set_action(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  action_ = value;
}
inline void AlterExtensionContentsStmt::set_action(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterExtensionContentsStmt.action)
}

// .pg_query.ObjectType objtype = 3 [json_name = "objtype"];
inline void AlterExtensionContentsStmt::clear_objtype() {
  objtype_ = 0;
}
inline ::pg_query::ObjectType AlterExtensionContentsStmt::_internal_objtype() const {
  return static_cast< ::pg_query::ObjectType >(objtype_);
}
inline ::pg_query::ObjectType AlterExtensionContentsStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterExtensionContentsStmt.objtype)
  return _internal_objtype();
}
inline void AlterExtensionContentsStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  
  objtype_ = value;
}
inline void AlterExtensionContentsStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterExtensionContentsStmt.objtype)
}

// .pg_query.Node object = 4 [json_name = "object"];
inline bool AlterExtensionContentsStmt::_internal_has_object() const {
  return this != internal_default_instance() && object_ != nullptr;
}
inline bool AlterExtensionContentsStmt::has_object() const {
  return _internal_has_object();
}
inline void AlterExtensionContentsStmt::clear_object() {
  if (GetArena() == nullptr && object_ != nullptr) {
    delete object_;
  }
  object_ = nullptr;
}
inline const ::pg_query::Node& AlterExtensionContentsStmt::_internal_object() const {
  const ::pg_query::Node* p = object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterExtensionContentsStmt::object() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterExtensionContentsStmt.object)
  return _internal_object();
}
inline void AlterExtensionContentsStmt::unsafe_arena_set_allocated_object(
    ::pg_query::Node* object) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(object_);
  }
  object_ = object;
  if (object) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterExtensionContentsStmt.object)
}
inline ::pg_query::Node* AlterExtensionContentsStmt::release_object() {
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* AlterExtensionContentsStmt::unsafe_arena_release_object() {
  // @@protoc_insertion_point(field_release:pg_query.AlterExtensionContentsStmt.object)
  
  ::pg_query::Node* temp = object_;
  object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterExtensionContentsStmt::_internal_mutable_object() {
  
  if (object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    object_ = p;
  }
  return object_;
}
inline ::pg_query::Node* AlterExtensionContentsStmt::mutable_object() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterExtensionContentsStmt.object)
  return _internal_mutable_object();
}
inline void AlterExtensionContentsStmt::set_allocated_object(::pg_query::Node* object) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete object_;
  }
  if (object) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(object);
    if (message_arena != submessage_arena) {
      object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, object, submessage_arena);
    }
    
  } else {
    
  }
  object_ = object;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterExtensionContentsStmt.object)
}

// -------------------------------------------------------------------

// CreateEventTrigStmt

// string trigname = 1 [json_name = "trigname"];
inline void CreateEventTrigStmt::clear_trigname() {
  trigname_.ClearToEmpty();
}
inline const std::string& CreateEventTrigStmt::trigname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateEventTrigStmt.trigname)
  return _internal_trigname();
}
inline void CreateEventTrigStmt::set_trigname(const std::string& value) {
  _internal_set_trigname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateEventTrigStmt.trigname)
}
inline std::string* CreateEventTrigStmt::mutable_trigname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateEventTrigStmt.trigname)
  return _internal_mutable_trigname();
}
inline const std::string& CreateEventTrigStmt::_internal_trigname() const {
  return trigname_.Get();
}
inline void CreateEventTrigStmt::_internal_set_trigname(const std::string& value) {
  
  trigname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateEventTrigStmt::set_trigname(std::string&& value) {
  
  trigname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateEventTrigStmt.trigname)
}
inline void CreateEventTrigStmt::set_trigname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  trigname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateEventTrigStmt.trigname)
}
inline void CreateEventTrigStmt::set_trigname(const char* value,
    size_t size) {
  
  trigname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateEventTrigStmt.trigname)
}
inline std::string* CreateEventTrigStmt::_internal_mutable_trigname() {
  
  return trigname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateEventTrigStmt::release_trigname() {
  // @@protoc_insertion_point(field_release:pg_query.CreateEventTrigStmt.trigname)
  return trigname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateEventTrigStmt::set_allocated_trigname(std::string* trigname) {
  if (trigname != nullptr) {
    
  } else {
    
  }
  trigname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), trigname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateEventTrigStmt.trigname)
}

// string eventname = 2 [json_name = "eventname"];
inline void CreateEventTrigStmt::clear_eventname() {
  eventname_.ClearToEmpty();
}
inline const std::string& CreateEventTrigStmt::eventname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateEventTrigStmt.eventname)
  return _internal_eventname();
}
inline void CreateEventTrigStmt::set_eventname(const std::string& value) {
  _internal_set_eventname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateEventTrigStmt.eventname)
}
inline std::string* CreateEventTrigStmt::mutable_eventname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateEventTrigStmt.eventname)
  return _internal_mutable_eventname();
}
inline const std::string& CreateEventTrigStmt::_internal_eventname() const {
  return eventname_.Get();
}
inline void CreateEventTrigStmt::_internal_set_eventname(const std::string& value) {
  
  eventname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateEventTrigStmt::set_eventname(std::string&& value) {
  
  eventname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateEventTrigStmt.eventname)
}
inline void CreateEventTrigStmt::set_eventname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  eventname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateEventTrigStmt.eventname)
}
inline void CreateEventTrigStmt::set_eventname(const char* value,
    size_t size) {
  
  eventname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateEventTrigStmt.eventname)
}
inline std::string* CreateEventTrigStmt::_internal_mutable_eventname() {
  
  return eventname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateEventTrigStmt::release_eventname() {
  // @@protoc_insertion_point(field_release:pg_query.CreateEventTrigStmt.eventname)
  return eventname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateEventTrigStmt::set_allocated_eventname(std::string* eventname) {
  if (eventname != nullptr) {
    
  } else {
    
  }
  eventname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), eventname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateEventTrigStmt.eventname)
}

// repeated .pg_query.Node whenclause = 3 [json_name = "whenclause"];
inline int CreateEventTrigStmt::_internal_whenclause_size() const {
  return whenclause_.size();
}
inline int CreateEventTrigStmt::whenclause_size() const {
  return _internal_whenclause_size();
}
inline void CreateEventTrigStmt::clear_whenclause() {
  whenclause_.Clear();
}
inline ::pg_query::Node* CreateEventTrigStmt::mutable_whenclause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateEventTrigStmt.whenclause)
  return whenclause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateEventTrigStmt::mutable_whenclause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateEventTrigStmt.whenclause)
  return &whenclause_;
}
inline const ::pg_query::Node& CreateEventTrigStmt::_internal_whenclause(int index) const {
  return whenclause_.Get(index);
}
inline const ::pg_query::Node& CreateEventTrigStmt::whenclause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateEventTrigStmt.whenclause)
  return _internal_whenclause(index);
}
inline ::pg_query::Node* CreateEventTrigStmt::_internal_add_whenclause() {
  return whenclause_.Add();
}
inline ::pg_query::Node* CreateEventTrigStmt::add_whenclause() {
  // @@protoc_insertion_point(field_add:pg_query.CreateEventTrigStmt.whenclause)
  return _internal_add_whenclause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateEventTrigStmt::whenclause() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateEventTrigStmt.whenclause)
  return whenclause_;
}

// repeated .pg_query.Node funcname = 4 [json_name = "funcname"];
inline int CreateEventTrigStmt::_internal_funcname_size() const {
  return funcname_.size();
}
inline int CreateEventTrigStmt::funcname_size() const {
  return _internal_funcname_size();
}
inline void CreateEventTrigStmt::clear_funcname() {
  funcname_.Clear();
}
inline ::pg_query::Node* CreateEventTrigStmt::mutable_funcname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateEventTrigStmt.funcname)
  return funcname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateEventTrigStmt::mutable_funcname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateEventTrigStmt.funcname)
  return &funcname_;
}
inline const ::pg_query::Node& CreateEventTrigStmt::_internal_funcname(int index) const {
  return funcname_.Get(index);
}
inline const ::pg_query::Node& CreateEventTrigStmt::funcname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateEventTrigStmt.funcname)
  return _internal_funcname(index);
}
inline ::pg_query::Node* CreateEventTrigStmt::_internal_add_funcname() {
  return funcname_.Add();
}
inline ::pg_query::Node* CreateEventTrigStmt::add_funcname() {
  // @@protoc_insertion_point(field_add:pg_query.CreateEventTrigStmt.funcname)
  return _internal_add_funcname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateEventTrigStmt::funcname() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateEventTrigStmt.funcname)
  return funcname_;
}

// -------------------------------------------------------------------

// AlterEventTrigStmt

// string trigname = 1 [json_name = "trigname"];
inline void AlterEventTrigStmt::clear_trigname() {
  trigname_.ClearToEmpty();
}
inline const std::string& AlterEventTrigStmt::trigname() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterEventTrigStmt.trigname)
  return _internal_trigname();
}
inline void AlterEventTrigStmt::set_trigname(const std::string& value) {
  _internal_set_trigname(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterEventTrigStmt.trigname)
}
inline std::string* AlterEventTrigStmt::mutable_trigname() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterEventTrigStmt.trigname)
  return _internal_mutable_trigname();
}
inline const std::string& AlterEventTrigStmt::_internal_trigname() const {
  return trigname_.Get();
}
inline void AlterEventTrigStmt::_internal_set_trigname(const std::string& value) {
  
  trigname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterEventTrigStmt::set_trigname(std::string&& value) {
  
  trigname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterEventTrigStmt.trigname)
}
inline void AlterEventTrigStmt::set_trigname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  trigname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterEventTrigStmt.trigname)
}
inline void AlterEventTrigStmt::set_trigname(const char* value,
    size_t size) {
  
  trigname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterEventTrigStmt.trigname)
}
inline std::string* AlterEventTrigStmt::_internal_mutable_trigname() {
  
  return trigname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterEventTrigStmt::release_trigname() {
  // @@protoc_insertion_point(field_release:pg_query.AlterEventTrigStmt.trigname)
  return trigname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterEventTrigStmt::set_allocated_trigname(std::string* trigname) {
  if (trigname != nullptr) {
    
  } else {
    
  }
  trigname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), trigname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterEventTrigStmt.trigname)
}

// string tgenabled = 2 [json_name = "tgenabled"];
inline void AlterEventTrigStmt::clear_tgenabled() {
  tgenabled_.ClearToEmpty();
}
inline const std::string& AlterEventTrigStmt::tgenabled() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterEventTrigStmt.tgenabled)
  return _internal_tgenabled();
}
inline void AlterEventTrigStmt::set_tgenabled(const std::string& value) {
  _internal_set_tgenabled(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterEventTrigStmt.tgenabled)
}
inline std::string* AlterEventTrigStmt::mutable_tgenabled() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterEventTrigStmt.tgenabled)
  return _internal_mutable_tgenabled();
}
inline const std::string& AlterEventTrigStmt::_internal_tgenabled() const {
  return tgenabled_.Get();
}
inline void AlterEventTrigStmt::_internal_set_tgenabled(const std::string& value) {
  
  tgenabled_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterEventTrigStmt::set_tgenabled(std::string&& value) {
  
  tgenabled_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterEventTrigStmt.tgenabled)
}
inline void AlterEventTrigStmt::set_tgenabled(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  tgenabled_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterEventTrigStmt.tgenabled)
}
inline void AlterEventTrigStmt::set_tgenabled(const char* value,
    size_t size) {
  
  tgenabled_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterEventTrigStmt.tgenabled)
}
inline std::string* AlterEventTrigStmt::_internal_mutable_tgenabled() {
  
  return tgenabled_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterEventTrigStmt::release_tgenabled() {
  // @@protoc_insertion_point(field_release:pg_query.AlterEventTrigStmt.tgenabled)
  return tgenabled_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterEventTrigStmt::set_allocated_tgenabled(std::string* tgenabled) {
  if (tgenabled != nullptr) {
    
  } else {
    
  }
  tgenabled_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tgenabled,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterEventTrigStmt.tgenabled)
}

// -------------------------------------------------------------------

// RefreshMatViewStmt

// bool concurrent = 1 [json_name = "concurrent"];
inline void RefreshMatViewStmt::clear_concurrent() {
  concurrent_ = false;
}
inline bool RefreshMatViewStmt::_internal_concurrent() const {
  return concurrent_;
}
inline bool RefreshMatViewStmt::concurrent() const {
  // @@protoc_insertion_point(field_get:pg_query.RefreshMatViewStmt.concurrent)
  return _internal_concurrent();
}
inline void RefreshMatViewStmt::_internal_set_concurrent(bool value) {
  
  concurrent_ = value;
}
inline void RefreshMatViewStmt::set_concurrent(bool value) {
  _internal_set_concurrent(value);
  // @@protoc_insertion_point(field_set:pg_query.RefreshMatViewStmt.concurrent)
}

// bool skip_data = 2 [json_name = "skipData"];
inline void RefreshMatViewStmt::clear_skip_data() {
  skip_data_ = false;
}
inline bool RefreshMatViewStmt::_internal_skip_data() const {
  return skip_data_;
}
inline bool RefreshMatViewStmt::skip_data() const {
  // @@protoc_insertion_point(field_get:pg_query.RefreshMatViewStmt.skip_data)
  return _internal_skip_data();
}
inline void RefreshMatViewStmt::_internal_set_skip_data(bool value) {
  
  skip_data_ = value;
}
inline void RefreshMatViewStmt::set_skip_data(bool value) {
  _internal_set_skip_data(value);
  // @@protoc_insertion_point(field_set:pg_query.RefreshMatViewStmt.skip_data)
}

// .pg_query.RangeVar relation = 3 [json_name = "relation"];
inline bool RefreshMatViewStmt::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool RefreshMatViewStmt::has_relation() const {
  return _internal_has_relation();
}
inline void RefreshMatViewStmt::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& RefreshMatViewStmt::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& RefreshMatViewStmt::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.RefreshMatViewStmt.relation)
  return _internal_relation();
}
inline void RefreshMatViewStmt::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RefreshMatViewStmt.relation)
}
inline ::pg_query::RangeVar* RefreshMatViewStmt::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* RefreshMatViewStmt::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.RefreshMatViewStmt.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* RefreshMatViewStmt::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* RefreshMatViewStmt::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.RefreshMatViewStmt.relation)
  return _internal_mutable_relation();
}
inline void RefreshMatViewStmt::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RefreshMatViewStmt.relation)
}

// -------------------------------------------------------------------

// ReplicaIdentityStmt

// string identity_type = 1 [json_name = "identity_type"];
inline void ReplicaIdentityStmt::clear_identity_type() {
  identity_type_.ClearToEmpty();
}
inline const std::string& ReplicaIdentityStmt::identity_type() const {
  // @@protoc_insertion_point(field_get:pg_query.ReplicaIdentityStmt.identity_type)
  return _internal_identity_type();
}
inline void ReplicaIdentityStmt::set_identity_type(const std::string& value) {
  _internal_set_identity_type(value);
  // @@protoc_insertion_point(field_set:pg_query.ReplicaIdentityStmt.identity_type)
}
inline std::string* ReplicaIdentityStmt::mutable_identity_type() {
  // @@protoc_insertion_point(field_mutable:pg_query.ReplicaIdentityStmt.identity_type)
  return _internal_mutable_identity_type();
}
inline const std::string& ReplicaIdentityStmt::_internal_identity_type() const {
  return identity_type_.Get();
}
inline void ReplicaIdentityStmt::_internal_set_identity_type(const std::string& value) {
  
  identity_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ReplicaIdentityStmt::set_identity_type(std::string&& value) {
  
  identity_type_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ReplicaIdentityStmt.identity_type)
}
inline void ReplicaIdentityStmt::set_identity_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  identity_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ReplicaIdentityStmt.identity_type)
}
inline void ReplicaIdentityStmt::set_identity_type(const char* value,
    size_t size) {
  
  identity_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ReplicaIdentityStmt.identity_type)
}
inline std::string* ReplicaIdentityStmt::_internal_mutable_identity_type() {
  
  return identity_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ReplicaIdentityStmt::release_identity_type() {
  // @@protoc_insertion_point(field_release:pg_query.ReplicaIdentityStmt.identity_type)
  return identity_type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ReplicaIdentityStmt::set_allocated_identity_type(std::string* identity_type) {
  if (identity_type != nullptr) {
    
  } else {
    
  }
  identity_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), identity_type,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ReplicaIdentityStmt.identity_type)
}

// string name = 2 [json_name = "name"];
inline void ReplicaIdentityStmt::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& ReplicaIdentityStmt::name() const {
  // @@protoc_insertion_point(field_get:pg_query.ReplicaIdentityStmt.name)
  return _internal_name();
}
inline void ReplicaIdentityStmt::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.ReplicaIdentityStmt.name)
}
inline std::string* ReplicaIdentityStmt::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.ReplicaIdentityStmt.name)
  return _internal_mutable_name();
}
inline const std::string& ReplicaIdentityStmt::_internal_name() const {
  return name_.Get();
}
inline void ReplicaIdentityStmt::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ReplicaIdentityStmt::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ReplicaIdentityStmt.name)
}
inline void ReplicaIdentityStmt::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ReplicaIdentityStmt.name)
}
inline void ReplicaIdentityStmt::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ReplicaIdentityStmt.name)
}
inline std::string* ReplicaIdentityStmt::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ReplicaIdentityStmt::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.ReplicaIdentityStmt.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ReplicaIdentityStmt::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ReplicaIdentityStmt.name)
}

// -------------------------------------------------------------------

// AlterSystemStmt

// .pg_query.VariableSetStmt setstmt = 1 [json_name = "setstmt"];
inline bool AlterSystemStmt::_internal_has_setstmt() const {
  return this != internal_default_instance() && setstmt_ != nullptr;
}
inline bool AlterSystemStmt::has_setstmt() const {
  return _internal_has_setstmt();
}
inline void AlterSystemStmt::clear_setstmt() {
  if (GetArena() == nullptr && setstmt_ != nullptr) {
    delete setstmt_;
  }
  setstmt_ = nullptr;
}
inline const ::pg_query::VariableSetStmt& AlterSystemStmt::_internal_setstmt() const {
  const ::pg_query::VariableSetStmt* p = setstmt_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::VariableSetStmt&>(
      ::pg_query::_VariableSetStmt_default_instance_);
}
inline const ::pg_query::VariableSetStmt& AlterSystemStmt::setstmt() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterSystemStmt.setstmt)
  return _internal_setstmt();
}
inline void AlterSystemStmt::unsafe_arena_set_allocated_setstmt(
    ::pg_query::VariableSetStmt* setstmt) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(setstmt_);
  }
  setstmt_ = setstmt;
  if (setstmt) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterSystemStmt.setstmt)
}
inline ::pg_query::VariableSetStmt* AlterSystemStmt::release_setstmt() {
  
  ::pg_query::VariableSetStmt* temp = setstmt_;
  setstmt_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::VariableSetStmt* AlterSystemStmt::unsafe_arena_release_setstmt() {
  // @@protoc_insertion_point(field_release:pg_query.AlterSystemStmt.setstmt)
  
  ::pg_query::VariableSetStmt* temp = setstmt_;
  setstmt_ = nullptr;
  return temp;
}
inline ::pg_query::VariableSetStmt* AlterSystemStmt::_internal_mutable_setstmt() {
  
  if (setstmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::VariableSetStmt>(GetArena());
    setstmt_ = p;
  }
  return setstmt_;
}
inline ::pg_query::VariableSetStmt* AlterSystemStmt::mutable_setstmt() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSystemStmt.setstmt)
  return _internal_mutable_setstmt();
}
inline void AlterSystemStmt::set_allocated_setstmt(::pg_query::VariableSetStmt* setstmt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete setstmt_;
  }
  if (setstmt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(setstmt);
    if (message_arena != submessage_arena) {
      setstmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, setstmt, submessage_arena);
    }
    
  } else {
    
  }
  setstmt_ = setstmt;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterSystemStmt.setstmt)
}

// -------------------------------------------------------------------

// CreatePolicyStmt

// string policy_name = 1 [json_name = "policy_name"];
inline void CreatePolicyStmt::clear_policy_name() {
  policy_name_.ClearToEmpty();
}
inline const std::string& CreatePolicyStmt::policy_name() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.policy_name)
  return _internal_policy_name();
}
inline void CreatePolicyStmt::set_policy_name(const std::string& value) {
  _internal_set_policy_name(value);
  // @@protoc_insertion_point(field_set:pg_query.CreatePolicyStmt.policy_name)
}
inline std::string* CreatePolicyStmt::mutable_policy_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePolicyStmt.policy_name)
  return _internal_mutable_policy_name();
}
inline const std::string& CreatePolicyStmt::_internal_policy_name() const {
  return policy_name_.Get();
}
inline void CreatePolicyStmt::_internal_set_policy_name(const std::string& value) {
  
  policy_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreatePolicyStmt::set_policy_name(std::string&& value) {
  
  policy_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreatePolicyStmt.policy_name)
}
inline void CreatePolicyStmt::set_policy_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  policy_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreatePolicyStmt.policy_name)
}
inline void CreatePolicyStmt::set_policy_name(const char* value,
    size_t size) {
  
  policy_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreatePolicyStmt.policy_name)
}
inline std::string* CreatePolicyStmt::_internal_mutable_policy_name() {
  
  return policy_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreatePolicyStmt::release_policy_name() {
  // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.policy_name)
  return policy_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreatePolicyStmt::set_allocated_policy_name(std::string* policy_name) {
  if (policy_name != nullptr) {
    
  } else {
    
  }
  policy_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), policy_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePolicyStmt.policy_name)
}

// .pg_query.RangeVar table = 2 [json_name = "table"];
inline bool CreatePolicyStmt::_internal_has_table() const {
  return this != internal_default_instance() && table_ != nullptr;
}
inline bool CreatePolicyStmt::has_table() const {
  return _internal_has_table();
}
inline void CreatePolicyStmt::clear_table() {
  if (GetArena() == nullptr && table_ != nullptr) {
    delete table_;
  }
  table_ = nullptr;
}
inline const ::pg_query::RangeVar& CreatePolicyStmt::_internal_table() const {
  const ::pg_query::RangeVar* p = table_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CreatePolicyStmt::table() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.table)
  return _internal_table();
}
inline void CreatePolicyStmt::unsafe_arena_set_allocated_table(
    ::pg_query::RangeVar* table) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(table_);
  }
  table_ = table;
  if (table) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreatePolicyStmt.table)
}
inline ::pg_query::RangeVar* CreatePolicyStmt::release_table() {
  
  ::pg_query::RangeVar* temp = table_;
  table_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* CreatePolicyStmt::unsafe_arena_release_table() {
  // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.table)
  
  ::pg_query::RangeVar* temp = table_;
  table_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CreatePolicyStmt::_internal_mutable_table() {
  
  if (table_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    table_ = p;
  }
  return table_;
}
inline ::pg_query::RangeVar* CreatePolicyStmt::mutable_table() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePolicyStmt.table)
  return _internal_mutable_table();
}
inline void CreatePolicyStmt::set_allocated_table(::pg_query::RangeVar* table) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete table_;
  }
  if (table) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(table);
    if (message_arena != submessage_arena) {
      table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, table, submessage_arena);
    }
    
  } else {
    
  }
  table_ = table;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePolicyStmt.table)
}

// string cmd_name = 3 [json_name = "cmd_name"];
inline void CreatePolicyStmt::clear_cmd_name() {
  cmd_name_.ClearToEmpty();
}
inline const std::string& CreatePolicyStmt::cmd_name() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.cmd_name)
  return _internal_cmd_name();
}
inline void CreatePolicyStmt::set_cmd_name(const std::string& value) {
  _internal_set_cmd_name(value);
  // @@protoc_insertion_point(field_set:pg_query.CreatePolicyStmt.cmd_name)
}
inline std::string* CreatePolicyStmt::mutable_cmd_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePolicyStmt.cmd_name)
  return _internal_mutable_cmd_name();
}
inline const std::string& CreatePolicyStmt::_internal_cmd_name() const {
  return cmd_name_.Get();
}
inline void CreatePolicyStmt::_internal_set_cmd_name(const std::string& value) {
  
  cmd_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreatePolicyStmt::set_cmd_name(std::string&& value) {
  
  cmd_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreatePolicyStmt.cmd_name)
}
inline void CreatePolicyStmt::set_cmd_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  cmd_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreatePolicyStmt.cmd_name)
}
inline void CreatePolicyStmt::set_cmd_name(const char* value,
    size_t size) {
  
  cmd_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreatePolicyStmt.cmd_name)
}
inline std::string* CreatePolicyStmt::_internal_mutable_cmd_name() {
  
  return cmd_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreatePolicyStmt::release_cmd_name() {
  // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.cmd_name)
  return cmd_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreatePolicyStmt::set_allocated_cmd_name(std::string* cmd_name) {
  if (cmd_name != nullptr) {
    
  } else {
    
  }
  cmd_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cmd_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePolicyStmt.cmd_name)
}

// bool permissive = 4 [json_name = "permissive"];
inline void CreatePolicyStmt::clear_permissive() {
  permissive_ = false;
}
inline bool CreatePolicyStmt::_internal_permissive() const {
  return permissive_;
}
inline bool CreatePolicyStmt::permissive() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.permissive)
  return _internal_permissive();
}
inline void CreatePolicyStmt::_internal_set_permissive(bool value) {
  
  permissive_ = value;
}
inline void CreatePolicyStmt::set_permissive(bool value) {
  _internal_set_permissive(value);
  // @@protoc_insertion_point(field_set:pg_query.CreatePolicyStmt.permissive)
}

// repeated .pg_query.Node roles = 5 [json_name = "roles"];
inline int CreatePolicyStmt::_internal_roles_size() const {
  return roles_.size();
}
inline int CreatePolicyStmt::roles_size() const {
  return _internal_roles_size();
}
inline void CreatePolicyStmt::clear_roles() {
  roles_.Clear();
}
inline ::pg_query::Node* CreatePolicyStmt::mutable_roles(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePolicyStmt.roles)
  return roles_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreatePolicyStmt::mutable_roles() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePolicyStmt.roles)
  return &roles_;
}
inline const ::pg_query::Node& CreatePolicyStmt::_internal_roles(int index) const {
  return roles_.Get(index);
}
inline const ::pg_query::Node& CreatePolicyStmt::roles(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.roles)
  return _internal_roles(index);
}
inline ::pg_query::Node* CreatePolicyStmt::_internal_add_roles() {
  return roles_.Add();
}
inline ::pg_query::Node* CreatePolicyStmt::add_roles() {
  // @@protoc_insertion_point(field_add:pg_query.CreatePolicyStmt.roles)
  return _internal_add_roles();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreatePolicyStmt::roles() const {
  // @@protoc_insertion_point(field_list:pg_query.CreatePolicyStmt.roles)
  return roles_;
}

// .pg_query.Node qual = 6 [json_name = "qual"];
inline bool CreatePolicyStmt::_internal_has_qual() const {
  return this != internal_default_instance() && qual_ != nullptr;
}
inline bool CreatePolicyStmt::has_qual() const {
  return _internal_has_qual();
}
inline void CreatePolicyStmt::clear_qual() {
  if (GetArena() == nullptr && qual_ != nullptr) {
    delete qual_;
  }
  qual_ = nullptr;
}
inline const ::pg_query::Node& CreatePolicyStmt::_internal_qual() const {
  const ::pg_query::Node* p = qual_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CreatePolicyStmt::qual() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.qual)
  return _internal_qual();
}
inline void CreatePolicyStmt::unsafe_arena_set_allocated_qual(
    ::pg_query::Node* qual) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(qual_);
  }
  qual_ = qual;
  if (qual) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreatePolicyStmt.qual)
}
inline ::pg_query::Node* CreatePolicyStmt::release_qual() {
  
  ::pg_query::Node* temp = qual_;
  qual_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CreatePolicyStmt::unsafe_arena_release_qual() {
  // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.qual)
  
  ::pg_query::Node* temp = qual_;
  qual_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CreatePolicyStmt::_internal_mutable_qual() {
  
  if (qual_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    qual_ = p;
  }
  return qual_;
}
inline ::pg_query::Node* CreatePolicyStmt::mutable_qual() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePolicyStmt.qual)
  return _internal_mutable_qual();
}
inline void CreatePolicyStmt::set_allocated_qual(::pg_query::Node* qual) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete qual_;
  }
  if (qual) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(qual);
    if (message_arena != submessage_arena) {
      qual = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, qual, submessage_arena);
    }
    
  } else {
    
  }
  qual_ = qual;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePolicyStmt.qual)
}

// .pg_query.Node with_check = 7 [json_name = "with_check"];
inline bool CreatePolicyStmt::_internal_has_with_check() const {
  return this != internal_default_instance() && with_check_ != nullptr;
}
inline bool CreatePolicyStmt::has_with_check() const {
  return _internal_has_with_check();
}
inline void CreatePolicyStmt::clear_with_check() {
  if (GetArena() == nullptr && with_check_ != nullptr) {
    delete with_check_;
  }
  with_check_ = nullptr;
}
inline const ::pg_query::Node& CreatePolicyStmt::_internal_with_check() const {
  const ::pg_query::Node* p = with_check_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CreatePolicyStmt::with_check() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.with_check)
  return _internal_with_check();
}
inline void CreatePolicyStmt::unsafe_arena_set_allocated_with_check(
    ::pg_query::Node* with_check) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(with_check_);
  }
  with_check_ = with_check;
  if (with_check) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreatePolicyStmt.with_check)
}
inline ::pg_query::Node* CreatePolicyStmt::release_with_check() {
  
  ::pg_query::Node* temp = with_check_;
  with_check_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CreatePolicyStmt::unsafe_arena_release_with_check() {
  // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.with_check)
  
  ::pg_query::Node* temp = with_check_;
  with_check_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CreatePolicyStmt::_internal_mutable_with_check() {
  
  if (with_check_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    with_check_ = p;
  }
  return with_check_;
}
inline ::pg_query::Node* CreatePolicyStmt::mutable_with_check() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePolicyStmt.with_check)
  return _internal_mutable_with_check();
}
inline void CreatePolicyStmt::set_allocated_with_check(::pg_query::Node* with_check) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete with_check_;
  }
  if (with_check) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(with_check);
    if (message_arena != submessage_arena) {
      with_check = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, with_check, submessage_arena);
    }
    
  } else {
    
  }
  with_check_ = with_check;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePolicyStmt.with_check)
}

// -------------------------------------------------------------------

// AlterPolicyStmt

// string policy_name = 1 [json_name = "policy_name"];
inline void AlterPolicyStmt::clear_policy_name() {
  policy_name_.ClearToEmpty();
}
inline const std::string& AlterPolicyStmt::policy_name() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.policy_name)
  return _internal_policy_name();
}
inline void AlterPolicyStmt::set_policy_name(const std::string& value) {
  _internal_set_policy_name(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterPolicyStmt.policy_name)
}
inline std::string* AlterPolicyStmt::mutable_policy_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPolicyStmt.policy_name)
  return _internal_mutable_policy_name();
}
inline const std::string& AlterPolicyStmt::_internal_policy_name() const {
  return policy_name_.Get();
}
inline void AlterPolicyStmt::_internal_set_policy_name(const std::string& value) {
  
  policy_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterPolicyStmt::set_policy_name(std::string&& value) {
  
  policy_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterPolicyStmt.policy_name)
}
inline void AlterPolicyStmt::set_policy_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  policy_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterPolicyStmt.policy_name)
}
inline void AlterPolicyStmt::set_policy_name(const char* value,
    size_t size) {
  
  policy_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterPolicyStmt.policy_name)
}
inline std::string* AlterPolicyStmt::_internal_mutable_policy_name() {
  
  return policy_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterPolicyStmt::release_policy_name() {
  // @@protoc_insertion_point(field_release:pg_query.AlterPolicyStmt.policy_name)
  return policy_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterPolicyStmt::set_allocated_policy_name(std::string* policy_name) {
  if (policy_name != nullptr) {
    
  } else {
    
  }
  policy_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), policy_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterPolicyStmt.policy_name)
}

// .pg_query.RangeVar table = 2 [json_name = "table"];
inline bool AlterPolicyStmt::_internal_has_table() const {
  return this != internal_default_instance() && table_ != nullptr;
}
inline bool AlterPolicyStmt::has_table() const {
  return _internal_has_table();
}
inline void AlterPolicyStmt::clear_table() {
  if (GetArena() == nullptr && table_ != nullptr) {
    delete table_;
  }
  table_ = nullptr;
}
inline const ::pg_query::RangeVar& AlterPolicyStmt::_internal_table() const {
  const ::pg_query::RangeVar* p = table_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& AlterPolicyStmt::table() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.table)
  return _internal_table();
}
inline void AlterPolicyStmt::unsafe_arena_set_allocated_table(
    ::pg_query::RangeVar* table) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(table_);
  }
  table_ = table;
  if (table) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterPolicyStmt.table)
}
inline ::pg_query::RangeVar* AlterPolicyStmt::release_table() {
  
  ::pg_query::RangeVar* temp = table_;
  table_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* AlterPolicyStmt::unsafe_arena_release_table() {
  // @@protoc_insertion_point(field_release:pg_query.AlterPolicyStmt.table)
  
  ::pg_query::RangeVar* temp = table_;
  table_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* AlterPolicyStmt::_internal_mutable_table() {
  
  if (table_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    table_ = p;
  }
  return table_;
}
inline ::pg_query::RangeVar* AlterPolicyStmt::mutable_table() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPolicyStmt.table)
  return _internal_mutable_table();
}
inline void AlterPolicyStmt::set_allocated_table(::pg_query::RangeVar* table) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete table_;
  }
  if (table) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(table);
    if (message_arena != submessage_arena) {
      table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, table, submessage_arena);
    }
    
  } else {
    
  }
  table_ = table;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterPolicyStmt.table)
}

// repeated .pg_query.Node roles = 3 [json_name = "roles"];
inline int AlterPolicyStmt::_internal_roles_size() const {
  return roles_.size();
}
inline int AlterPolicyStmt::roles_size() const {
  return _internal_roles_size();
}
inline void AlterPolicyStmt::clear_roles() {
  roles_.Clear();
}
inline ::pg_query::Node* AlterPolicyStmt::mutable_roles(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPolicyStmt.roles)
  return roles_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterPolicyStmt::mutable_roles() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterPolicyStmt.roles)
  return &roles_;
}
inline const ::pg_query::Node& AlterPolicyStmt::_internal_roles(int index) const {
  return roles_.Get(index);
}
inline const ::pg_query::Node& AlterPolicyStmt::roles(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.roles)
  return _internal_roles(index);
}
inline ::pg_query::Node* AlterPolicyStmt::_internal_add_roles() {
  return roles_.Add();
}
inline ::pg_query::Node* AlterPolicyStmt::add_roles() {
  // @@protoc_insertion_point(field_add:pg_query.AlterPolicyStmt.roles)
  return _internal_add_roles();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterPolicyStmt::roles() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterPolicyStmt.roles)
  return roles_;
}

// .pg_query.Node qual = 4 [json_name = "qual"];
inline bool AlterPolicyStmt::_internal_has_qual() const {
  return this != internal_default_instance() && qual_ != nullptr;
}
inline bool AlterPolicyStmt::has_qual() const {
  return _internal_has_qual();
}
inline void AlterPolicyStmt::clear_qual() {
  if (GetArena() == nullptr && qual_ != nullptr) {
    delete qual_;
  }
  qual_ = nullptr;
}
inline const ::pg_query::Node& AlterPolicyStmt::_internal_qual() const {
  const ::pg_query::Node* p = qual_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterPolicyStmt::qual() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.qual)
  return _internal_qual();
}
inline void AlterPolicyStmt::unsafe_arena_set_allocated_qual(
    ::pg_query::Node* qual) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(qual_);
  }
  qual_ = qual;
  if (qual) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterPolicyStmt.qual)
}
inline ::pg_query::Node* AlterPolicyStmt::release_qual() {
  
  ::pg_query::Node* temp = qual_;
  qual_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* AlterPolicyStmt::unsafe_arena_release_qual() {
  // @@protoc_insertion_point(field_release:pg_query.AlterPolicyStmt.qual)
  
  ::pg_query::Node* temp = qual_;
  qual_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterPolicyStmt::_internal_mutable_qual() {
  
  if (qual_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    qual_ = p;
  }
  return qual_;
}
inline ::pg_query::Node* AlterPolicyStmt::mutable_qual() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPolicyStmt.qual)
  return _internal_mutable_qual();
}
inline void AlterPolicyStmt::set_allocated_qual(::pg_query::Node* qual) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete qual_;
  }
  if (qual) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(qual);
    if (message_arena != submessage_arena) {
      qual = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, qual, submessage_arena);
    }
    
  } else {
    
  }
  qual_ = qual;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterPolicyStmt.qual)
}

// .pg_query.Node with_check = 5 [json_name = "with_check"];
inline bool AlterPolicyStmt::_internal_has_with_check() const {
  return this != internal_default_instance() && with_check_ != nullptr;
}
inline bool AlterPolicyStmt::has_with_check() const {
  return _internal_has_with_check();
}
inline void AlterPolicyStmt::clear_with_check() {
  if (GetArena() == nullptr && with_check_ != nullptr) {
    delete with_check_;
  }
  with_check_ = nullptr;
}
inline const ::pg_query::Node& AlterPolicyStmt::_internal_with_check() const {
  const ::pg_query::Node* p = with_check_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterPolicyStmt::with_check() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.with_check)
  return _internal_with_check();
}
inline void AlterPolicyStmt::unsafe_arena_set_allocated_with_check(
    ::pg_query::Node* with_check) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(with_check_);
  }
  with_check_ = with_check;
  if (with_check) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterPolicyStmt.with_check)
}
inline ::pg_query::Node* AlterPolicyStmt::release_with_check() {
  
  ::pg_query::Node* temp = with_check_;
  with_check_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* AlterPolicyStmt::unsafe_arena_release_with_check() {
  // @@protoc_insertion_point(field_release:pg_query.AlterPolicyStmt.with_check)
  
  ::pg_query::Node* temp = with_check_;
  with_check_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterPolicyStmt::_internal_mutable_with_check() {
  
  if (with_check_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    with_check_ = p;
  }
  return with_check_;
}
inline ::pg_query::Node* AlterPolicyStmt::mutable_with_check() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPolicyStmt.with_check)
  return _internal_mutable_with_check();
}
inline void AlterPolicyStmt::set_allocated_with_check(::pg_query::Node* with_check) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete with_check_;
  }
  if (with_check) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(with_check);
    if (message_arena != submessage_arena) {
      with_check = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, with_check, submessage_arena);
    }
    
  } else {
    
  }
  with_check_ = with_check;
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterPolicyStmt.with_check)
}

// -------------------------------------------------------------------

// CreateTransformStmt

// bool replace = 1 [json_name = "replace"];
inline void CreateTransformStmt::clear_replace() {
  replace_ = false;
}
inline bool CreateTransformStmt::_internal_replace() const {
  return replace_;
}
inline bool CreateTransformStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.replace)
  return _internal_replace();
}
inline void CreateTransformStmt::_internal_set_replace(bool value) {
  
  replace_ = value;
}
inline void CreateTransformStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTransformStmt.replace)
}

// .pg_query.TypeName type_name = 2 [json_name = "type_name"];
inline bool CreateTransformStmt::_internal_has_type_name() const {
  return this != internal_default_instance() && type_name_ != nullptr;
}
inline bool CreateTransformStmt::has_type_name() const {
  return _internal_has_type_name();
}
inline void CreateTransformStmt::clear_type_name() {
  if (GetArena() == nullptr && type_name_ != nullptr) {
    delete type_name_;
  }
  type_name_ = nullptr;
}
inline const ::pg_query::TypeName& CreateTransformStmt::_internal_type_name() const {
  const ::pg_query::TypeName* p = type_name_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(
      ::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& CreateTransformStmt::type_name() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.type_name)
  return _internal_type_name();
}
inline void CreateTransformStmt::unsafe_arena_set_allocated_type_name(
    ::pg_query::TypeName* type_name) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_name_);
  }
  type_name_ = type_name;
  if (type_name) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTransformStmt.type_name)
}
inline ::pg_query::TypeName* CreateTransformStmt::release_type_name() {
  
  ::pg_query::TypeName* temp = type_name_;
  type_name_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TypeName* CreateTransformStmt::unsafe_arena_release_type_name() {
  // @@protoc_insertion_point(field_release:pg_query.CreateTransformStmt.type_name)
  
  ::pg_query::TypeName* temp = type_name_;
  type_name_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateTransformStmt::_internal_mutable_type_name() {
  
  if (type_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    type_name_ = p;
  }
  return type_name_;
}
inline ::pg_query::TypeName* CreateTransformStmt::mutable_type_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTransformStmt.type_name)
  return _internal_mutable_type_name();
}
inline void CreateTransformStmt::set_allocated_type_name(::pg_query::TypeName* type_name) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete type_name_;
  }
  if (type_name) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_name);
    if (message_arena != submessage_arena) {
      type_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, type_name, submessage_arena);
    }
    
  } else {
    
  }
  type_name_ = type_name;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTransformStmt.type_name)
}

// string lang = 3 [json_name = "lang"];
inline void CreateTransformStmt::clear_lang() {
  lang_.ClearToEmpty();
}
inline const std::string& CreateTransformStmt::lang() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.lang)
  return _internal_lang();
}
inline void CreateTransformStmt::set_lang(const std::string& value) {
  _internal_set_lang(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTransformStmt.lang)
}
inline std::string* CreateTransformStmt::mutable_lang() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTransformStmt.lang)
  return _internal_mutable_lang();
}
inline const std::string& CreateTransformStmt::_internal_lang() const {
  return lang_.Get();
}
inline void CreateTransformStmt::_internal_set_lang(const std::string& value) {
  
  lang_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateTransformStmt::set_lang(std::string&& value) {
  
  lang_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateTransformStmt.lang)
}
inline void CreateTransformStmt::set_lang(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  lang_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateTransformStmt.lang)
}
inline void CreateTransformStmt::set_lang(const char* value,
    size_t size) {
  
  lang_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateTransformStmt.lang)
}
inline std::string* CreateTransformStmt::_internal_mutable_lang() {
  
  return lang_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateTransformStmt::release_lang() {
  // @@protoc_insertion_point(field_release:pg_query.CreateTransformStmt.lang)
  return lang_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateTransformStmt::set_allocated_lang(std::string* lang) {
  if (lang != nullptr) {
    
  } else {
    
  }
  lang_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), lang,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTransformStmt.lang)
}

// .pg_query.ObjectWithArgs fromsql = 4 [json_name = "fromsql"];
inline bool CreateTransformStmt::_internal_has_fromsql() const {
  return this != internal_default_instance() && fromsql_ != nullptr;
}
inline bool CreateTransformStmt::has_fromsql() const {
  return _internal_has_fromsql();
}
inline void CreateTransformStmt::clear_fromsql() {
  if (GetArena() == nullptr && fromsql_ != nullptr) {
    delete fromsql_;
  }
  fromsql_ = nullptr;
}
inline const ::pg_query::ObjectWithArgs& CreateTransformStmt::_internal_fromsql() const {
  const ::pg_query::ObjectWithArgs* p = fromsql_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::ObjectWithArgs&>(
      ::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& CreateTransformStmt::fromsql() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.fromsql)
  return _internal_fromsql();
}
inline void CreateTransformStmt::unsafe_arena_set_allocated_fromsql(
    ::pg_query::ObjectWithArgs* fromsql) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fromsql_);
  }
  fromsql_ = fromsql;
  if (fromsql) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTransformStmt.fromsql)
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::release_fromsql() {
  
  ::pg_query::ObjectWithArgs* temp = fromsql_;
  fromsql_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::unsafe_arena_release_fromsql() {
  // @@protoc_insertion_point(field_release:pg_query.CreateTransformStmt.fromsql)
  
  ::pg_query::ObjectWithArgs* temp = fromsql_;
  fromsql_ = nullptr;
  return temp;
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::_internal_mutable_fromsql() {
  
  if (fromsql_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArena());
    fromsql_ = p;
  }
  return fromsql_;
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::mutable_fromsql() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTransformStmt.fromsql)
  return _internal_mutable_fromsql();
}
inline void CreateTransformStmt::set_allocated_fromsql(::pg_query::ObjectWithArgs* fromsql) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete fromsql_;
  }
  if (fromsql) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fromsql);
    if (message_arena != submessage_arena) {
      fromsql = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fromsql, submessage_arena);
    }
    
  } else {
    
  }
  fromsql_ = fromsql;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTransformStmt.fromsql)
}

// .pg_query.ObjectWithArgs tosql = 5 [json_name = "tosql"];
inline bool CreateTransformStmt::_internal_has_tosql() const {
  return this != internal_default_instance() && tosql_ != nullptr;
}
inline bool CreateTransformStmt::has_tosql() const {
  return _internal_has_tosql();
}
inline void CreateTransformStmt::clear_tosql() {
  if (GetArena() == nullptr && tosql_ != nullptr) {
    delete tosql_;
  }
  tosql_ = nullptr;
}
inline const ::pg_query::ObjectWithArgs& CreateTransformStmt::_internal_tosql() const {
  const ::pg_query::ObjectWithArgs* p = tosql_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::ObjectWithArgs&>(
      ::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& CreateTransformStmt::tosql() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.tosql)
  return _internal_tosql();
}
inline void CreateTransformStmt::unsafe_arena_set_allocated_tosql(
    ::pg_query::ObjectWithArgs* tosql) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tosql_);
  }
  tosql_ = tosql;
  if (tosql) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTransformStmt.tosql)
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::release_tosql() {
  
  ::pg_query::ObjectWithArgs* temp = tosql_;
  tosql_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::unsafe_arena_release_tosql() {
  // @@protoc_insertion_point(field_release:pg_query.CreateTransformStmt.tosql)
  
  ::pg_query::ObjectWithArgs* temp = tosql_;
  tosql_ = nullptr;
  return temp;
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::_internal_mutable_tosql() {
  
  if (tosql_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArena());
    tosql_ = p;
  }
  return tosql_;
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::mutable_tosql() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTransformStmt.tosql)
  return _internal_mutable_tosql();
}
inline void CreateTransformStmt::set_allocated_tosql(::pg_query::ObjectWithArgs* tosql) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete tosql_;
  }
  if (tosql) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tosql);
    if (message_arena != submessage_arena) {
      tosql = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tosql, submessage_arena);
    }
    
  } else {
    
  }
  tosql_ = tosql;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTransformStmt.tosql)
}

// -------------------------------------------------------------------

// CreateAmStmt

// string amname = 1 [json_name = "amname"];
inline void CreateAmStmt::clear_amname() {
  amname_.ClearToEmpty();
}
inline const std::string& CreateAmStmt::amname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateAmStmt.amname)
  return _internal_amname();
}
inline void CreateAmStmt::set_amname(const std::string& value) {
  _internal_set_amname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateAmStmt.amname)
}
inline std::string* CreateAmStmt::mutable_amname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateAmStmt.amname)
  return _internal_mutable_amname();
}
inline const std::string& CreateAmStmt::_internal_amname() const {
  return amname_.Get();
}
inline void CreateAmStmt::_internal_set_amname(const std::string& value) {
  
  amname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateAmStmt::set_amname(std::string&& value) {
  
  amname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateAmStmt.amname)
}
inline void CreateAmStmt::set_amname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  amname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateAmStmt.amname)
}
inline void CreateAmStmt::set_amname(const char* value,
    size_t size) {
  
  amname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateAmStmt.amname)
}
inline std::string* CreateAmStmt::_internal_mutable_amname() {
  
  return amname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateAmStmt::release_amname() {
  // @@protoc_insertion_point(field_release:pg_query.CreateAmStmt.amname)
  return amname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateAmStmt::set_allocated_amname(std::string* amname) {
  if (amname != nullptr) {
    
  } else {
    
  }
  amname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), amname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateAmStmt.amname)
}

// repeated .pg_query.Node handler_name = 2 [json_name = "handler_name"];
inline int CreateAmStmt::_internal_handler_name_size() const {
  return handler_name_.size();
}
inline int CreateAmStmt::handler_name_size() const {
  return _internal_handler_name_size();
}
inline void CreateAmStmt::clear_handler_name() {
  handler_name_.Clear();
}
inline ::pg_query::Node* CreateAmStmt::mutable_handler_name(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateAmStmt.handler_name)
  return handler_name_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateAmStmt::mutable_handler_name() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateAmStmt.handler_name)
  return &handler_name_;
}
inline const ::pg_query::Node& CreateAmStmt::_internal_handler_name(int index) const {
  return handler_name_.Get(index);
}
inline const ::pg_query::Node& CreateAmStmt::handler_name(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateAmStmt.handler_name)
  return _internal_handler_name(index);
}
inline ::pg_query::Node* CreateAmStmt::_internal_add_handler_name() {
  return handler_name_.Add();
}
inline ::pg_query::Node* CreateAmStmt::add_handler_name() {
  // @@protoc_insertion_point(field_add:pg_query.CreateAmStmt.handler_name)
  return _internal_add_handler_name();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateAmStmt::handler_name() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateAmStmt.handler_name)
  return handler_name_;
}

// string amtype = 3 [json_name = "amtype"];
inline void CreateAmStmt::clear_amtype() {
  amtype_.ClearToEmpty();
}
inline const std::string& CreateAmStmt::amtype() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateAmStmt.amtype)
  return _internal_amtype();
}
inline void CreateAmStmt::set_amtype(const std::string& value) {
  _internal_set_amtype(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateAmStmt.amtype)
}
inline std::string* CreateAmStmt::mutable_amtype() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateAmStmt.amtype)
  return _internal_mutable_amtype();
}
inline const std::string& CreateAmStmt::_internal_amtype() const {
  return amtype_.Get();
}
inline void CreateAmStmt::_internal_set_amtype(const std::string& value) {
  
  amtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateAmStmt::set_amtype(std::string&& value) {
  
  amtype_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateAmStmt.amtype)
}
inline void CreateAmStmt::set_amtype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  amtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateAmStmt.amtype)
}
inline void CreateAmStmt::set_amtype(const char* value,
    size_t size) {
  
  amtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateAmStmt.amtype)
}
inline std::string* CreateAmStmt::_internal_mutable_amtype() {
  
  return amtype_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateAmStmt::release_amtype() {
  // @@protoc_insertion_point(field_release:pg_query.CreateAmStmt.amtype)
  return amtype_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateAmStmt::set_allocated_amtype(std::string* amtype) {
  if (amtype != nullptr) {
    
  } else {
    
  }
  amtype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), amtype,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateAmStmt.amtype)
}

// -------------------------------------------------------------------

// CreatePublicationStmt

// string pubname = 1 [json_name = "pubname"];
inline void CreatePublicationStmt::clear_pubname() {
  pubname_.ClearToEmpty();
}
inline const std::string& CreatePublicationStmt::pubname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePublicationStmt.pubname)
  return _internal_pubname();
}
inline void CreatePublicationStmt::set_pubname(const std::string& value) {
  _internal_set_pubname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreatePublicationStmt.pubname)
}
inline std::string* CreatePublicationStmt::mutable_pubname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePublicationStmt.pubname)
  return _internal_mutable_pubname();
}
inline const std::string& CreatePublicationStmt::_internal_pubname() const {
  return pubname_.Get();
}
inline void CreatePublicationStmt::_internal_set_pubname(const std::string& value) {
  
  pubname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreatePublicationStmt::set_pubname(std::string&& value) {
  
  pubname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreatePublicationStmt.pubname)
}
inline void CreatePublicationStmt::set_pubname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  pubname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreatePublicationStmt.pubname)
}
inline void CreatePublicationStmt::set_pubname(const char* value,
    size_t size) {
  
  pubname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreatePublicationStmt.pubname)
}
inline std::string* CreatePublicationStmt::_internal_mutable_pubname() {
  
  return pubname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreatePublicationStmt::release_pubname() {
  // @@protoc_insertion_point(field_release:pg_query.CreatePublicationStmt.pubname)
  return pubname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreatePublicationStmt::set_allocated_pubname(std::string* pubname) {
  if (pubname != nullptr) {
    
  } else {
    
  }
  pubname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pubname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePublicationStmt.pubname)
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int CreatePublicationStmt::_internal_options_size() const {
  return options_.size();
}
inline int CreatePublicationStmt::options_size() const {
  return _internal_options_size();
}
inline void CreatePublicationStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CreatePublicationStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePublicationStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreatePublicationStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePublicationStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CreatePublicationStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CreatePublicationStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePublicationStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CreatePublicationStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CreatePublicationStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreatePublicationStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreatePublicationStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreatePublicationStmt.options)
  return options_;
}

// repeated .pg_query.Node tables = 3 [json_name = "tables"];
inline int CreatePublicationStmt::_internal_tables_size() const {
  return tables_.size();
}
inline int CreatePublicationStmt::tables_size() const {
  return _internal_tables_size();
}
inline void CreatePublicationStmt::clear_tables() {
  tables_.Clear();
}
inline ::pg_query::Node* CreatePublicationStmt::mutable_tables(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePublicationStmt.tables)
  return tables_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreatePublicationStmt::mutable_tables() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePublicationStmt.tables)
  return &tables_;
}
inline const ::pg_query::Node& CreatePublicationStmt::_internal_tables(int index) const {
  return tables_.Get(index);
}
inline const ::pg_query::Node& CreatePublicationStmt::tables(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePublicationStmt.tables)
  return _internal_tables(index);
}
inline ::pg_query::Node* CreatePublicationStmt::_internal_add_tables() {
  return tables_.Add();
}
inline ::pg_query::Node* CreatePublicationStmt::add_tables() {
  // @@protoc_insertion_point(field_add:pg_query.CreatePublicationStmt.tables)
  return _internal_add_tables();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreatePublicationStmt::tables() const {
  // @@protoc_insertion_point(field_list:pg_query.CreatePublicationStmt.tables)
  return tables_;
}

// bool for_all_tables = 4 [json_name = "for_all_tables"];
inline void CreatePublicationStmt::clear_for_all_tables() {
  for_all_tables_ = false;
}
inline bool CreatePublicationStmt::_internal_for_all_tables() const {
  return for_all_tables_;
}
inline bool CreatePublicationStmt::for_all_tables() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePublicationStmt.for_all_tables)
  return _internal_for_all_tables();
}
inline void CreatePublicationStmt::_internal_set_for_all_tables(bool value) {
  
  for_all_tables_ = value;
}
inline void CreatePublicationStmt::set_for_all_tables(bool value) {
  _internal_set_for_all_tables(value);
  // @@protoc_insertion_point(field_set:pg_query.CreatePublicationStmt.for_all_tables)
}

// -------------------------------------------------------------------

// AlterPublicationStmt

// string pubname = 1 [json_name = "pubname"];
inline void AlterPublicationStmt::clear_pubname() {
  pubname_.ClearToEmpty();
}
inline const std::string& AlterPublicationStmt::pubname() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.pubname)
  return _internal_pubname();
}
inline void AlterPublicationStmt::set_pubname(const std::string& value) {
  _internal_set_pubname(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterPublicationStmt.pubname)
}
inline std::string* AlterPublicationStmt::mutable_pubname() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPublicationStmt.pubname)
  return _internal_mutable_pubname();
}
inline const std::string& AlterPublicationStmt::_internal_pubname() const {
  return pubname_.Get();
}
inline void AlterPublicationStmt::_internal_set_pubname(const std::string& value) {
  
  pubname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterPublicationStmt::set_pubname(std::string&& value) {
  
  pubname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterPublicationStmt.pubname)
}
inline void AlterPublicationStmt::set_pubname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  pubname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterPublicationStmt.pubname)
}
inline void AlterPublicationStmt::set_pubname(const char* value,
    size_t size) {
  
  pubname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterPublicationStmt.pubname)
}
inline std::string* AlterPublicationStmt::_internal_mutable_pubname() {
  
  return pubname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterPublicationStmt::release_pubname() {
  // @@protoc_insertion_point(field_release:pg_query.AlterPublicationStmt.pubname)
  return pubname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterPublicationStmt::set_allocated_pubname(std::string* pubname) {
  if (pubname != nullptr) {
    
  } else {
    
  }
  pubname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pubname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterPublicationStmt.pubname)
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int AlterPublicationStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterPublicationStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterPublicationStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterPublicationStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPublicationStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterPublicationStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterPublicationStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterPublicationStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterPublicationStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterPublicationStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterPublicationStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterPublicationStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterPublicationStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterPublicationStmt.options)
  return options_;
}

// repeated .pg_query.Node tables = 3 [json_name = "tables"];
inline int AlterPublicationStmt::_internal_tables_size() const {
  return tables_.size();
}
inline int AlterPublicationStmt::tables_size() const {
  return _internal_tables_size();
}
inline void AlterPublicationStmt::clear_tables() {
  tables_.Clear();
}
inline ::pg_query::Node* AlterPublicationStmt::mutable_tables(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPublicationStmt.tables)
  return tables_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterPublicationStmt::mutable_tables() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterPublicationStmt.tables)
  return &tables_;
}
inline const ::pg_query::Node& AlterPublicationStmt::_internal_tables(int index) const {
  return tables_.Get(index);
}
inline const ::pg_query::Node& AlterPublicationStmt::tables(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.tables)
  return _internal_tables(index);
}
inline ::pg_query::Node* AlterPublicationStmt::_internal_add_tables() {
  return tables_.Add();
}
inline ::pg_query::Node* AlterPublicationStmt::add_tables() {
  // @@protoc_insertion_point(field_add:pg_query.AlterPublicationStmt.tables)
  return _internal_add_tables();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterPublicationStmt::tables() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterPublicationStmt.tables)
  return tables_;
}

// bool for_all_tables = 4 [json_name = "for_all_tables"];
inline void AlterPublicationStmt::clear_for_all_tables() {
  for_all_tables_ = false;
}
inline bool AlterPublicationStmt::_internal_for_all_tables() const {
  return for_all_tables_;
}
inline bool AlterPublicationStmt::for_all_tables() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.for_all_tables)
  return _internal_for_all_tables();
}
inline void AlterPublicationStmt::_internal_set_for_all_tables(bool value) {
  
  for_all_tables_ = value;
}
inline void AlterPublicationStmt::set_for_all_tables(bool value) {
  _internal_set_for_all_tables(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterPublicationStmt.for_all_tables)
}

// .pg_query.DefElemAction table_action = 5 [json_name = "tableAction"];
inline void AlterPublicationStmt::clear_table_action() {
  table_action_ = 0;
}
inline ::pg_query::DefElemAction AlterPublicationStmt::_internal_table_action() const {
  return static_cast< ::pg_query::DefElemAction >(table_action_);
}
inline ::pg_query::DefElemAction AlterPublicationStmt::table_action() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.table_action)
  return _internal_table_action();
}
inline void AlterPublicationStmt::_internal_set_table_action(::pg_query::DefElemAction value) {
  
  table_action_ = value;
}
inline void AlterPublicationStmt::set_table_action(::pg_query::DefElemAction value) {
  _internal_set_table_action(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterPublicationStmt.table_action)
}

// -------------------------------------------------------------------

// CreateSubscriptionStmt

// string subname = 1 [json_name = "subname"];
inline void CreateSubscriptionStmt::clear_subname() {
  subname_.ClearToEmpty();
}
inline const std::string& CreateSubscriptionStmt::subname() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSubscriptionStmt.subname)
  return _internal_subname();
}
inline void CreateSubscriptionStmt::set_subname(const std::string& value) {
  _internal_set_subname(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateSubscriptionStmt.subname)
}
inline std::string* CreateSubscriptionStmt::mutable_subname() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSubscriptionStmt.subname)
  return _internal_mutable_subname();
}
inline const std::string& CreateSubscriptionStmt::_internal_subname() const {
  return subname_.Get();
}
inline void CreateSubscriptionStmt::_internal_set_subname(const std::string& value) {
  
  subname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateSubscriptionStmt::set_subname(std::string&& value) {
  
  subname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateSubscriptionStmt.subname)
}
inline void CreateSubscriptionStmt::set_subname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  subname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateSubscriptionStmt.subname)
}
inline void CreateSubscriptionStmt::set_subname(const char* value,
    size_t size) {
  
  subname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateSubscriptionStmt.subname)
}
inline std::string* CreateSubscriptionStmt::_internal_mutable_subname() {
  
  return subname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateSubscriptionStmt::release_subname() {
  // @@protoc_insertion_point(field_release:pg_query.CreateSubscriptionStmt.subname)
  return subname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateSubscriptionStmt::set_allocated_subname(std::string* subname) {
  if (subname != nullptr) {
    
  } else {
    
  }
  subname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), subname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateSubscriptionStmt.subname)
}

// string conninfo = 2 [json_name = "conninfo"];
inline void CreateSubscriptionStmt::clear_conninfo() {
  conninfo_.ClearToEmpty();
}
inline const std::string& CreateSubscriptionStmt::conninfo() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSubscriptionStmt.conninfo)
  return _internal_conninfo();
}
inline void CreateSubscriptionStmt::set_conninfo(const std::string& value) {
  _internal_set_conninfo(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateSubscriptionStmt.conninfo)
}
inline std::string* CreateSubscriptionStmt::mutable_conninfo() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSubscriptionStmt.conninfo)
  return _internal_mutable_conninfo();
}
inline const std::string& CreateSubscriptionStmt::_internal_conninfo() const {
  return conninfo_.Get();
}
inline void CreateSubscriptionStmt::_internal_set_conninfo(const std::string& value) {
  
  conninfo_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateSubscriptionStmt::set_conninfo(std::string&& value) {
  
  conninfo_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateSubscriptionStmt.conninfo)
}
inline void CreateSubscriptionStmt::set_conninfo(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  conninfo_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateSubscriptionStmt.conninfo)
}
inline void CreateSubscriptionStmt::set_conninfo(const char* value,
    size_t size) {
  
  conninfo_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateSubscriptionStmt.conninfo)
}
inline std::string* CreateSubscriptionStmt::_internal_mutable_conninfo() {
  
  return conninfo_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateSubscriptionStmt::release_conninfo() {
  // @@protoc_insertion_point(field_release:pg_query.CreateSubscriptionStmt.conninfo)
  return conninfo_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateSubscriptionStmt::set_allocated_conninfo(std::string* conninfo) {
  if (conninfo != nullptr) {
    
  } else {
    
  }
  conninfo_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), conninfo,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateSubscriptionStmt.conninfo)
}

// repeated .pg_query.Node publication = 3 [json_name = "publication"];
inline int CreateSubscriptionStmt::_internal_publication_size() const {
  return publication_.size();
}
inline int CreateSubscriptionStmt::publication_size() const {
  return _internal_publication_size();
}
inline void CreateSubscriptionStmt::clear_publication() {
  publication_.Clear();
}
inline ::pg_query::Node* CreateSubscriptionStmt::mutable_publication(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSubscriptionStmt.publication)
  return publication_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateSubscriptionStmt::mutable_publication() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateSubscriptionStmt.publication)
  return &publication_;
}
inline const ::pg_query::Node& CreateSubscriptionStmt::_internal_publication(int index) const {
  return publication_.Get(index);
}
inline const ::pg_query::Node& CreateSubscriptionStmt::publication(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSubscriptionStmt.publication)
  return _internal_publication(index);
}
inline ::pg_query::Node* CreateSubscriptionStmt::_internal_add_publication() {
  return publication_.Add();
}
inline ::pg_query::Node* CreateSubscriptionStmt::add_publication() {
  // @@protoc_insertion_point(field_add:pg_query.CreateSubscriptionStmt.publication)
  return _internal_add_publication();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateSubscriptionStmt::publication() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateSubscriptionStmt.publication)
  return publication_;
}

// repeated .pg_query.Node options = 4 [json_name = "options"];
inline int CreateSubscriptionStmt::_internal_options_size() const {
  return options_.size();
}
inline int CreateSubscriptionStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateSubscriptionStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* CreateSubscriptionStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSubscriptionStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateSubscriptionStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateSubscriptionStmt.options)
  return &options_;
}
inline const ::pg_query::Node& CreateSubscriptionStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& CreateSubscriptionStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSubscriptionStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* CreateSubscriptionStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* CreateSubscriptionStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.CreateSubscriptionStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateSubscriptionStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateSubscriptionStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// AlterSubscriptionStmt

// .pg_query.AlterSubscriptionType kind = 1 [json_name = "kind"];
inline void AlterSubscriptionStmt::clear_kind() {
  kind_ = 0;
}
inline ::pg_query::AlterSubscriptionType AlterSubscriptionStmt::_internal_kind() const {
  return static_cast< ::pg_query::AlterSubscriptionType >(kind_);
}
inline ::pg_query::AlterSubscriptionType AlterSubscriptionStmt::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.kind)
  return _internal_kind();
}
inline void AlterSubscriptionStmt::_internal_set_kind(::pg_query::AlterSubscriptionType value) {
  
  kind_ = value;
}
inline void AlterSubscriptionStmt::set_kind(::pg_query::AlterSubscriptionType value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterSubscriptionStmt.kind)
}

// string subname = 2 [json_name = "subname"];
inline void AlterSubscriptionStmt::clear_subname() {
  subname_.ClearToEmpty();
}
inline const std::string& AlterSubscriptionStmt::subname() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.subname)
  return _internal_subname();
}
inline void AlterSubscriptionStmt::set_subname(const std::string& value) {
  _internal_set_subname(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterSubscriptionStmt.subname)
}
inline std::string* AlterSubscriptionStmt::mutable_subname() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSubscriptionStmt.subname)
  return _internal_mutable_subname();
}
inline const std::string& AlterSubscriptionStmt::_internal_subname() const {
  return subname_.Get();
}
inline void AlterSubscriptionStmt::_internal_set_subname(const std::string& value) {
  
  subname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterSubscriptionStmt::set_subname(std::string&& value) {
  
  subname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterSubscriptionStmt.subname)
}
inline void AlterSubscriptionStmt::set_subname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  subname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterSubscriptionStmt.subname)
}
inline void AlterSubscriptionStmt::set_subname(const char* value,
    size_t size) {
  
  subname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterSubscriptionStmt.subname)
}
inline std::string* AlterSubscriptionStmt::_internal_mutable_subname() {
  
  return subname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterSubscriptionStmt::release_subname() {
  // @@protoc_insertion_point(field_release:pg_query.AlterSubscriptionStmt.subname)
  return subname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterSubscriptionStmt::set_allocated_subname(std::string* subname) {
  if (subname != nullptr) {
    
  } else {
    
  }
  subname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), subname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterSubscriptionStmt.subname)
}

// string conninfo = 3 [json_name = "conninfo"];
inline void AlterSubscriptionStmt::clear_conninfo() {
  conninfo_.ClearToEmpty();
}
inline const std::string& AlterSubscriptionStmt::conninfo() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.conninfo)
  return _internal_conninfo();
}
inline void AlterSubscriptionStmt::set_conninfo(const std::string& value) {
  _internal_set_conninfo(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterSubscriptionStmt.conninfo)
}
inline std::string* AlterSubscriptionStmt::mutable_conninfo() {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSubscriptionStmt.conninfo)
  return _internal_mutable_conninfo();
}
inline const std::string& AlterSubscriptionStmt::_internal_conninfo() const {
  return conninfo_.Get();
}
inline void AlterSubscriptionStmt::_internal_set_conninfo(const std::string& value) {
  
  conninfo_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AlterSubscriptionStmt::set_conninfo(std::string&& value) {
  
  conninfo_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AlterSubscriptionStmt.conninfo)
}
inline void AlterSubscriptionStmt::set_conninfo(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  conninfo_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AlterSubscriptionStmt.conninfo)
}
inline void AlterSubscriptionStmt::set_conninfo(const char* value,
    size_t size) {
  
  conninfo_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AlterSubscriptionStmt.conninfo)
}
inline std::string* AlterSubscriptionStmt::_internal_mutable_conninfo() {
  
  return conninfo_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AlterSubscriptionStmt::release_conninfo() {
  // @@protoc_insertion_point(field_release:pg_query.AlterSubscriptionStmt.conninfo)
  return conninfo_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AlterSubscriptionStmt::set_allocated_conninfo(std::string* conninfo) {
  if (conninfo != nullptr) {
    
  } else {
    
  }
  conninfo_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), conninfo,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterSubscriptionStmt.conninfo)
}

// repeated .pg_query.Node publication = 4 [json_name = "publication"];
inline int AlterSubscriptionStmt::_internal_publication_size() const {
  return publication_.size();
}
inline int AlterSubscriptionStmt::publication_size() const {
  return _internal_publication_size();
}
inline void AlterSubscriptionStmt::clear_publication() {
  publication_.Clear();
}
inline ::pg_query::Node* AlterSubscriptionStmt::mutable_publication(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSubscriptionStmt.publication)
  return publication_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterSubscriptionStmt::mutable_publication() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterSubscriptionStmt.publication)
  return &publication_;
}
inline const ::pg_query::Node& AlterSubscriptionStmt::_internal_publication(int index) const {
  return publication_.Get(index);
}
inline const ::pg_query::Node& AlterSubscriptionStmt::publication(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.publication)
  return _internal_publication(index);
}
inline ::pg_query::Node* AlterSubscriptionStmt::_internal_add_publication() {
  return publication_.Add();
}
inline ::pg_query::Node* AlterSubscriptionStmt::add_publication() {
  // @@protoc_insertion_point(field_add:pg_query.AlterSubscriptionStmt.publication)
  return _internal_add_publication();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterSubscriptionStmt::publication() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterSubscriptionStmt.publication)
  return publication_;
}

// repeated .pg_query.Node options = 5 [json_name = "options"];
inline int AlterSubscriptionStmt::_internal_options_size() const {
  return options_.size();
}
inline int AlterSubscriptionStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterSubscriptionStmt::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* AlterSubscriptionStmt::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSubscriptionStmt.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterSubscriptionStmt::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterSubscriptionStmt.options)
  return &options_;
}
inline const ::pg_query::Node& AlterSubscriptionStmt::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& AlterSubscriptionStmt::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.options)
  return _internal_options(index);
}
inline ::pg_query::Node* AlterSubscriptionStmt::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* AlterSubscriptionStmt::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.AlterSubscriptionStmt.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterSubscriptionStmt::options() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterSubscriptionStmt.options)
  return options_;
}

// -------------------------------------------------------------------

// DropSubscriptionStmt

// string subname = 1 [json_name = "subname"];
inline void DropSubscriptionStmt::clear_subname() {
  subname_.ClearToEmpty();
}
inline const std::string& DropSubscriptionStmt::subname() const {
  // @@protoc_insertion_point(field_get:pg_query.DropSubscriptionStmt.subname)
  return _internal_subname();
}
inline void DropSubscriptionStmt::set_subname(const std::string& value) {
  _internal_set_subname(value);
  // @@protoc_insertion_point(field_set:pg_query.DropSubscriptionStmt.subname)
}
inline std::string* DropSubscriptionStmt::mutable_subname() {
  // @@protoc_insertion_point(field_mutable:pg_query.DropSubscriptionStmt.subname)
  return _internal_mutable_subname();
}
inline const std::string& DropSubscriptionStmt::_internal_subname() const {
  return subname_.Get();
}
inline void DropSubscriptionStmt::_internal_set_subname(const std::string& value) {
  
  subname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void DropSubscriptionStmt::set_subname(std::string&& value) {
  
  subname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.DropSubscriptionStmt.subname)
}
inline void DropSubscriptionStmt::set_subname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  subname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.DropSubscriptionStmt.subname)
}
inline void DropSubscriptionStmt::set_subname(const char* value,
    size_t size) {
  
  subname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.DropSubscriptionStmt.subname)
}
inline std::string* DropSubscriptionStmt::_internal_mutable_subname() {
  
  return subname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* DropSubscriptionStmt::release_subname() {
  // @@protoc_insertion_point(field_release:pg_query.DropSubscriptionStmt.subname)
  return subname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void DropSubscriptionStmt::set_allocated_subname(std::string* subname) {
  if (subname != nullptr) {
    
  } else {
    
  }
  subname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), subname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.DropSubscriptionStmt.subname)
}

// bool missing_ok = 2 [json_name = "missing_ok"];
inline void DropSubscriptionStmt::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool DropSubscriptionStmt::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool DropSubscriptionStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.DropSubscriptionStmt.missing_ok)
  return _internal_missing_ok();
}
inline void DropSubscriptionStmt::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void DropSubscriptionStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.DropSubscriptionStmt.missing_ok)
}

// .pg_query.DropBehavior behavior = 3 [json_name = "behavior"];
inline void DropSubscriptionStmt::clear_behavior() {
  behavior_ = 0;
}
inline ::pg_query::DropBehavior DropSubscriptionStmt::_internal_behavior() const {
  return static_cast< ::pg_query::DropBehavior >(behavior_);
}
inline ::pg_query::DropBehavior DropSubscriptionStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.DropSubscriptionStmt.behavior)
  return _internal_behavior();
}
inline void DropSubscriptionStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  
  behavior_ = value;
}
inline void DropSubscriptionStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.DropSubscriptionStmt.behavior)
}

// -------------------------------------------------------------------

// CreateStatsStmt

// repeated .pg_query.Node defnames = 1 [json_name = "defnames"];
inline int CreateStatsStmt::_internal_defnames_size() const {
  return defnames_.size();
}
inline int CreateStatsStmt::defnames_size() const {
  return _internal_defnames_size();
}
inline void CreateStatsStmt::clear_defnames() {
  defnames_.Clear();
}
inline ::pg_query::Node* CreateStatsStmt::mutable_defnames(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.defnames)
  return defnames_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateStatsStmt::mutable_defnames() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStatsStmt.defnames)
  return &defnames_;
}
inline const ::pg_query::Node& CreateStatsStmt::_internal_defnames(int index) const {
  return defnames_.Get(index);
}
inline const ::pg_query::Node& CreateStatsStmt::defnames(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.defnames)
  return _internal_defnames(index);
}
inline ::pg_query::Node* CreateStatsStmt::_internal_add_defnames() {
  return defnames_.Add();
}
inline ::pg_query::Node* CreateStatsStmt::add_defnames() {
  // @@protoc_insertion_point(field_add:pg_query.CreateStatsStmt.defnames)
  return _internal_add_defnames();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateStatsStmt::defnames() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateStatsStmt.defnames)
  return defnames_;
}

// repeated .pg_query.Node stat_types = 2 [json_name = "stat_types"];
inline int CreateStatsStmt::_internal_stat_types_size() const {
  return stat_types_.size();
}
inline int CreateStatsStmt::stat_types_size() const {
  return _internal_stat_types_size();
}
inline void CreateStatsStmt::clear_stat_types() {
  stat_types_.Clear();
}
inline ::pg_query::Node* CreateStatsStmt::mutable_stat_types(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.stat_types)
  return stat_types_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateStatsStmt::mutable_stat_types() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStatsStmt.stat_types)
  return &stat_types_;
}
inline const ::pg_query::Node& CreateStatsStmt::_internal_stat_types(int index) const {
  return stat_types_.Get(index);
}
inline const ::pg_query::Node& CreateStatsStmt::stat_types(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.stat_types)
  return _internal_stat_types(index);
}
inline ::pg_query::Node* CreateStatsStmt::_internal_add_stat_types() {
  return stat_types_.Add();
}
inline ::pg_query::Node* CreateStatsStmt::add_stat_types() {
  // @@protoc_insertion_point(field_add:pg_query.CreateStatsStmt.stat_types)
  return _internal_add_stat_types();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateStatsStmt::stat_types() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateStatsStmt.stat_types)
  return stat_types_;
}

// repeated .pg_query.Node exprs = 3 [json_name = "exprs"];
inline int CreateStatsStmt::_internal_exprs_size() const {
  return exprs_.size();
}
inline int CreateStatsStmt::exprs_size() const {
  return _internal_exprs_size();
}
inline void CreateStatsStmt::clear_exprs() {
  exprs_.Clear();
}
inline ::pg_query::Node* CreateStatsStmt::mutable_exprs(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.exprs)
  return exprs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateStatsStmt::mutable_exprs() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStatsStmt.exprs)
  return &exprs_;
}
inline const ::pg_query::Node& CreateStatsStmt::_internal_exprs(int index) const {
  return exprs_.Get(index);
}
inline const ::pg_query::Node& CreateStatsStmt::exprs(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.exprs)
  return _internal_exprs(index);
}
inline ::pg_query::Node* CreateStatsStmt::_internal_add_exprs() {
  return exprs_.Add();
}
inline ::pg_query::Node* CreateStatsStmt::add_exprs() {
  // @@protoc_insertion_point(field_add:pg_query.CreateStatsStmt.exprs)
  return _internal_add_exprs();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateStatsStmt::exprs() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateStatsStmt.exprs)
  return exprs_;
}

// repeated .pg_query.Node relations = 4 [json_name = "relations"];
inline int CreateStatsStmt::_internal_relations_size() const {
  return relations_.size();
}
inline int CreateStatsStmt::relations_size() const {
  return _internal_relations_size();
}
inline void CreateStatsStmt::clear_relations() {
  relations_.Clear();
}
inline ::pg_query::Node* CreateStatsStmt::mutable_relations(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.relations)
  return relations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateStatsStmt::mutable_relations() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStatsStmt.relations)
  return &relations_;
}
inline const ::pg_query::Node& CreateStatsStmt::_internal_relations(int index) const {
  return relations_.Get(index);
}
inline const ::pg_query::Node& CreateStatsStmt::relations(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.relations)
  return _internal_relations(index);
}
inline ::pg_query::Node* CreateStatsStmt::_internal_add_relations() {
  return relations_.Add();
}
inline ::pg_query::Node* CreateStatsStmt::add_relations() {
  // @@protoc_insertion_point(field_add:pg_query.CreateStatsStmt.relations)
  return _internal_add_relations();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateStatsStmt::relations() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateStatsStmt.relations)
  return relations_;
}

// string stxcomment = 5 [json_name = "stxcomment"];
inline void CreateStatsStmt::clear_stxcomment() {
  stxcomment_.ClearToEmpty();
}
inline const std::string& CreateStatsStmt::stxcomment() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.stxcomment)
  return _internal_stxcomment();
}
inline void CreateStatsStmt::set_stxcomment(const std::string& value) {
  _internal_set_stxcomment(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateStatsStmt.stxcomment)
}
inline std::string* CreateStatsStmt::mutable_stxcomment() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.stxcomment)
  return _internal_mutable_stxcomment();
}
inline const std::string& CreateStatsStmt::_internal_stxcomment() const {
  return stxcomment_.Get();
}
inline void CreateStatsStmt::_internal_set_stxcomment(const std::string& value) {
  
  stxcomment_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CreateStatsStmt::set_stxcomment(std::string&& value) {
  
  stxcomment_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CreateStatsStmt.stxcomment)
}
inline void CreateStatsStmt::set_stxcomment(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  stxcomment_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CreateStatsStmt.stxcomment)
}
inline void CreateStatsStmt::set_stxcomment(const char* value,
    size_t size) {
  
  stxcomment_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CreateStatsStmt.stxcomment)
}
inline std::string* CreateStatsStmt::_internal_mutable_stxcomment() {
  
  return stxcomment_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CreateStatsStmt::release_stxcomment() {
  // @@protoc_insertion_point(field_release:pg_query.CreateStatsStmt.stxcomment)
  return stxcomment_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CreateStatsStmt::set_allocated_stxcomment(std::string* stxcomment) {
  if (stxcomment != nullptr) {
    
  } else {
    
  }
  stxcomment_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), stxcomment,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStatsStmt.stxcomment)
}

// bool if_not_exists = 6 [json_name = "if_not_exists"];
inline void CreateStatsStmt::clear_if_not_exists() {
  if_not_exists_ = false;
}
inline bool CreateStatsStmt::_internal_if_not_exists() const {
  return if_not_exists_;
}
inline bool CreateStatsStmt::if_not_exists() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.if_not_exists)
  return _internal_if_not_exists();
}
inline void CreateStatsStmt::_internal_set_if_not_exists(bool value) {
  
  if_not_exists_ = value;
}
inline void CreateStatsStmt::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateStatsStmt.if_not_exists)
}

// -------------------------------------------------------------------

// AlterCollationStmt

// repeated .pg_query.Node collname = 1 [json_name = "collname"];
inline int AlterCollationStmt::_internal_collname_size() const {
  return collname_.size();
}
inline int AlterCollationStmt::collname_size() const {
  return _internal_collname_size();
}
inline void AlterCollationStmt::clear_collname() {
  collname_.Clear();
}
inline ::pg_query::Node* AlterCollationStmt::mutable_collname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterCollationStmt.collname)
  return collname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterCollationStmt::mutable_collname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterCollationStmt.collname)
  return &collname_;
}
inline const ::pg_query::Node& AlterCollationStmt::_internal_collname(int index) const {
  return collname_.Get(index);
}
inline const ::pg_query::Node& AlterCollationStmt::collname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterCollationStmt.collname)
  return _internal_collname(index);
}
inline ::pg_query::Node* AlterCollationStmt::_internal_add_collname() {
  return collname_.Add();
}
inline ::pg_query::Node* AlterCollationStmt::add_collname() {
  // @@protoc_insertion_point(field_add:pg_query.AlterCollationStmt.collname)
  return _internal_add_collname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterCollationStmt::collname() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterCollationStmt.collname)
  return collname_;
}

// -------------------------------------------------------------------

// CallStmt

// .pg_query.FuncCall funccall = 1 [json_name = "funccall"];
inline bool CallStmt::_internal_has_funccall() const {
  return this != internal_default_instance() && funccall_ != nullptr;
}
inline bool CallStmt::has_funccall() const {
  return _internal_has_funccall();
}
inline void CallStmt::clear_funccall() {
  if (GetArena() == nullptr && funccall_ != nullptr) {
    delete funccall_;
  }
  funccall_ = nullptr;
}
inline const ::pg_query::FuncCall& CallStmt::_internal_funccall() const {
  const ::pg_query::FuncCall* p = funccall_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::FuncCall&>(
      ::pg_query::_FuncCall_default_instance_);
}
inline const ::pg_query::FuncCall& CallStmt::funccall() const {
  // @@protoc_insertion_point(field_get:pg_query.CallStmt.funccall)
  return _internal_funccall();
}
inline void CallStmt::unsafe_arena_set_allocated_funccall(
    ::pg_query::FuncCall* funccall) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(funccall_);
  }
  funccall_ = funccall;
  if (funccall) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CallStmt.funccall)
}
inline ::pg_query::FuncCall* CallStmt::release_funccall() {
  
  ::pg_query::FuncCall* temp = funccall_;
  funccall_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::FuncCall* CallStmt::unsafe_arena_release_funccall() {
  // @@protoc_insertion_point(field_release:pg_query.CallStmt.funccall)
  
  ::pg_query::FuncCall* temp = funccall_;
  funccall_ = nullptr;
  return temp;
}
inline ::pg_query::FuncCall* CallStmt::_internal_mutable_funccall() {
  
  if (funccall_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::FuncCall>(GetArena());
    funccall_ = p;
  }
  return funccall_;
}
inline ::pg_query::FuncCall* CallStmt::mutable_funccall() {
  // @@protoc_insertion_point(field_mutable:pg_query.CallStmt.funccall)
  return _internal_mutable_funccall();
}
inline void CallStmt::set_allocated_funccall(::pg_query::FuncCall* funccall) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete funccall_;
  }
  if (funccall) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(funccall);
    if (message_arena != submessage_arena) {
      funccall = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, funccall, submessage_arena);
    }
    
  } else {
    
  }
  funccall_ = funccall;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CallStmt.funccall)
}

// .pg_query.FuncExpr funcexpr = 2 [json_name = "funcexpr"];
inline bool CallStmt::_internal_has_funcexpr() const {
  return this != internal_default_instance() && funcexpr_ != nullptr;
}
inline bool CallStmt::has_funcexpr() const {
  return _internal_has_funcexpr();
}
inline void CallStmt::clear_funcexpr() {
  if (GetArena() == nullptr && funcexpr_ != nullptr) {
    delete funcexpr_;
  }
  funcexpr_ = nullptr;
}
inline const ::pg_query::FuncExpr& CallStmt::_internal_funcexpr() const {
  const ::pg_query::FuncExpr* p = funcexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::FuncExpr&>(
      ::pg_query::_FuncExpr_default_instance_);
}
inline const ::pg_query::FuncExpr& CallStmt::funcexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.CallStmt.funcexpr)
  return _internal_funcexpr();
}
inline void CallStmt::unsafe_arena_set_allocated_funcexpr(
    ::pg_query::FuncExpr* funcexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(funcexpr_);
  }
  funcexpr_ = funcexpr;
  if (funcexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CallStmt.funcexpr)
}
inline ::pg_query::FuncExpr* CallStmt::release_funcexpr() {
  
  ::pg_query::FuncExpr* temp = funcexpr_;
  funcexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::FuncExpr* CallStmt::unsafe_arena_release_funcexpr() {
  // @@protoc_insertion_point(field_release:pg_query.CallStmt.funcexpr)
  
  ::pg_query::FuncExpr* temp = funcexpr_;
  funcexpr_ = nullptr;
  return temp;
}
inline ::pg_query::FuncExpr* CallStmt::_internal_mutable_funcexpr() {
  
  if (funcexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::FuncExpr>(GetArena());
    funcexpr_ = p;
  }
  return funcexpr_;
}
inline ::pg_query::FuncExpr* CallStmt::mutable_funcexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.CallStmt.funcexpr)
  return _internal_mutable_funcexpr();
}
inline void CallStmt::set_allocated_funcexpr(::pg_query::FuncExpr* funcexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete funcexpr_;
  }
  if (funcexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(funcexpr);
    if (message_arena != submessage_arena) {
      funcexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, funcexpr, submessage_arena);
    }
    
  } else {
    
  }
  funcexpr_ = funcexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CallStmt.funcexpr)
}

// -------------------------------------------------------------------

// AlterStatsStmt

// repeated .pg_query.Node defnames = 1 [json_name = "defnames"];
inline int AlterStatsStmt::_internal_defnames_size() const {
  return defnames_.size();
}
inline int AlterStatsStmt::defnames_size() const {
  return _internal_defnames_size();
}
inline void AlterStatsStmt::clear_defnames() {
  defnames_.Clear();
}
inline ::pg_query::Node* AlterStatsStmt::mutable_defnames(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterStatsStmt.defnames)
  return defnames_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AlterStatsStmt::mutable_defnames() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterStatsStmt.defnames)
  return &defnames_;
}
inline const ::pg_query::Node& AlterStatsStmt::_internal_defnames(int index) const {
  return defnames_.Get(index);
}
inline const ::pg_query::Node& AlterStatsStmt::defnames(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AlterStatsStmt.defnames)
  return _internal_defnames(index);
}
inline ::pg_query::Node* AlterStatsStmt::_internal_add_defnames() {
  return defnames_.Add();
}
inline ::pg_query::Node* AlterStatsStmt::add_defnames() {
  // @@protoc_insertion_point(field_add:pg_query.AlterStatsStmt.defnames)
  return _internal_add_defnames();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AlterStatsStmt::defnames() const {
  // @@protoc_insertion_point(field_list:pg_query.AlterStatsStmt.defnames)
  return defnames_;
}

// int32 stxstattarget = 2 [json_name = "stxstattarget"];
inline void AlterStatsStmt::clear_stxstattarget() {
  stxstattarget_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 AlterStatsStmt::_internal_stxstattarget() const {
  return stxstattarget_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 AlterStatsStmt::stxstattarget() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterStatsStmt.stxstattarget)
  return _internal_stxstattarget();
}
inline void AlterStatsStmt::_internal_set_stxstattarget(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  stxstattarget_ = value;
}
inline void AlterStatsStmt::set_stxstattarget(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_stxstattarget(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterStatsStmt.stxstattarget)
}

// bool missing_ok = 3 [json_name = "missing_ok"];
inline void AlterStatsStmt::clear_missing_ok() {
  missing_ok_ = false;
}
inline bool AlterStatsStmt::_internal_missing_ok() const {
  return missing_ok_;
}
inline bool AlterStatsStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterStatsStmt.missing_ok)
  return _internal_missing_ok();
}
inline void AlterStatsStmt::_internal_set_missing_ok(bool value) {
  
  missing_ok_ = value;
}
inline void AlterStatsStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterStatsStmt.missing_ok)
}

// -------------------------------------------------------------------

// A_Expr

// .pg_query.A_Expr_Kind kind = 1 [json_name = "kind"];
inline void A_Expr::clear_kind() {
  kind_ = 0;
}
inline ::pg_query::A_Expr_Kind A_Expr::_internal_kind() const {
  return static_cast< ::pg_query::A_Expr_Kind >(kind_);
}
inline ::pg_query::A_Expr_Kind A_Expr::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.A_Expr.kind)
  return _internal_kind();
}
inline void A_Expr::_internal_set_kind(::pg_query::A_Expr_Kind value) {
  
  kind_ = value;
}
inline void A_Expr::set_kind(::pg_query::A_Expr_Kind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.A_Expr.kind)
}

// repeated .pg_query.Node name = 2 [json_name = "name"];
inline int A_Expr::_internal_name_size() const {
  return name_.size();
}
inline int A_Expr::name_size() const {
  return _internal_name_size();
}
inline void A_Expr::clear_name() {
  name_.Clear();
}
inline ::pg_query::Node* A_Expr::mutable_name(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.A_Expr.name)
  return name_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
A_Expr::mutable_name() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.A_Expr.name)
  return &name_;
}
inline const ::pg_query::Node& A_Expr::_internal_name(int index) const {
  return name_.Get(index);
}
inline const ::pg_query::Node& A_Expr::name(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.A_Expr.name)
  return _internal_name(index);
}
inline ::pg_query::Node* A_Expr::_internal_add_name() {
  return name_.Add();
}
inline ::pg_query::Node* A_Expr::add_name() {
  // @@protoc_insertion_point(field_add:pg_query.A_Expr.name)
  return _internal_add_name();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
A_Expr::name() const {
  // @@protoc_insertion_point(field_list:pg_query.A_Expr.name)
  return name_;
}

// .pg_query.Node lexpr = 3 [json_name = "lexpr"];
inline bool A_Expr::_internal_has_lexpr() const {
  return this != internal_default_instance() && lexpr_ != nullptr;
}
inline bool A_Expr::has_lexpr() const {
  return _internal_has_lexpr();
}
inline void A_Expr::clear_lexpr() {
  if (GetArena() == nullptr && lexpr_ != nullptr) {
    delete lexpr_;
  }
  lexpr_ = nullptr;
}
inline const ::pg_query::Node& A_Expr::_internal_lexpr() const {
  const ::pg_query::Node* p = lexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& A_Expr::lexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.A_Expr.lexpr)
  return _internal_lexpr();
}
inline void A_Expr::unsafe_arena_set_allocated_lexpr(
    ::pg_query::Node* lexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lexpr_);
  }
  lexpr_ = lexpr;
  if (lexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Expr.lexpr)
}
inline ::pg_query::Node* A_Expr::release_lexpr() {
  
  ::pg_query::Node* temp = lexpr_;
  lexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* A_Expr::unsafe_arena_release_lexpr() {
  // @@protoc_insertion_point(field_release:pg_query.A_Expr.lexpr)
  
  ::pg_query::Node* temp = lexpr_;
  lexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* A_Expr::_internal_mutable_lexpr() {
  
  if (lexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    lexpr_ = p;
  }
  return lexpr_;
}
inline ::pg_query::Node* A_Expr::mutable_lexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.A_Expr.lexpr)
  return _internal_mutable_lexpr();
}
inline void A_Expr::set_allocated_lexpr(::pg_query::Node* lexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete lexpr_;
  }
  if (lexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(lexpr);
    if (message_arena != submessage_arena) {
      lexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lexpr, submessage_arena);
    }
    
  } else {
    
  }
  lexpr_ = lexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.A_Expr.lexpr)
}

// .pg_query.Node rexpr = 4 [json_name = "rexpr"];
inline bool A_Expr::_internal_has_rexpr() const {
  return this != internal_default_instance() && rexpr_ != nullptr;
}
inline bool A_Expr::has_rexpr() const {
  return _internal_has_rexpr();
}
inline void A_Expr::clear_rexpr() {
  if (GetArena() == nullptr && rexpr_ != nullptr) {
    delete rexpr_;
  }
  rexpr_ = nullptr;
}
inline const ::pg_query::Node& A_Expr::_internal_rexpr() const {
  const ::pg_query::Node* p = rexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& A_Expr::rexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.A_Expr.rexpr)
  return _internal_rexpr();
}
inline void A_Expr::unsafe_arena_set_allocated_rexpr(
    ::pg_query::Node* rexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rexpr_);
  }
  rexpr_ = rexpr;
  if (rexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Expr.rexpr)
}
inline ::pg_query::Node* A_Expr::release_rexpr() {
  
  ::pg_query::Node* temp = rexpr_;
  rexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* A_Expr::unsafe_arena_release_rexpr() {
  // @@protoc_insertion_point(field_release:pg_query.A_Expr.rexpr)
  
  ::pg_query::Node* temp = rexpr_;
  rexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* A_Expr::_internal_mutable_rexpr() {
  
  if (rexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    rexpr_ = p;
  }
  return rexpr_;
}
inline ::pg_query::Node* A_Expr::mutable_rexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.A_Expr.rexpr)
  return _internal_mutable_rexpr();
}
inline void A_Expr::set_allocated_rexpr(::pg_query::Node* rexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete rexpr_;
  }
  if (rexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(rexpr);
    if (message_arena != submessage_arena) {
      rexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rexpr, submessage_arena);
    }
    
  } else {
    
  }
  rexpr_ = rexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.A_Expr.rexpr)
}

// int32 location = 5 [json_name = "location"];
inline void A_Expr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 A_Expr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 A_Expr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.A_Expr.location)
  return _internal_location();
}
inline void A_Expr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void A_Expr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.A_Expr.location)
}

// -------------------------------------------------------------------

// ColumnRef

// repeated .pg_query.Node fields = 1 [json_name = "fields"];
inline int ColumnRef::_internal_fields_size() const {
  return fields_.size();
}
inline int ColumnRef::fields_size() const {
  return _internal_fields_size();
}
inline void ColumnRef::clear_fields() {
  fields_.Clear();
}
inline ::pg_query::Node* ColumnRef::mutable_fields(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnRef.fields)
  return fields_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ColumnRef::mutable_fields() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ColumnRef.fields)
  return &fields_;
}
inline const ::pg_query::Node& ColumnRef::_internal_fields(int index) const {
  return fields_.Get(index);
}
inline const ::pg_query::Node& ColumnRef::fields(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnRef.fields)
  return _internal_fields(index);
}
inline ::pg_query::Node* ColumnRef::_internal_add_fields() {
  return fields_.Add();
}
inline ::pg_query::Node* ColumnRef::add_fields() {
  // @@protoc_insertion_point(field_add:pg_query.ColumnRef.fields)
  return _internal_add_fields();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ColumnRef::fields() const {
  // @@protoc_insertion_point(field_list:pg_query.ColumnRef.fields)
  return fields_;
}

// int32 location = 2 [json_name = "location"];
inline void ColumnRef::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ColumnRef::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ColumnRef::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnRef.location)
  return _internal_location();
}
inline void ColumnRef::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void ColumnRef::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnRef.location)
}

// -------------------------------------------------------------------

// ParamRef

// int32 number = 1 [json_name = "number"];
inline void ParamRef::clear_number() {
  number_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ParamRef::_internal_number() const {
  return number_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ParamRef::number() const {
  // @@protoc_insertion_point(field_get:pg_query.ParamRef.number)
  return _internal_number();
}
inline void ParamRef::_internal_set_number(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  number_ = value;
}
inline void ParamRef::set_number(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_number(value);
  // @@protoc_insertion_point(field_set:pg_query.ParamRef.number)
}

// int32 location = 2 [json_name = "location"];
inline void ParamRef::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ParamRef::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ParamRef::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ParamRef.location)
  return _internal_location();
}
inline void ParamRef::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void ParamRef::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ParamRef.location)
}

// -------------------------------------------------------------------

// A_Const

// .pg_query.Node val = 1 [json_name = "val"];
inline bool A_Const::_internal_has_val() const {
  return this != internal_default_instance() && val_ != nullptr;
}
inline bool A_Const::has_val() const {
  return _internal_has_val();
}
inline void A_Const::clear_val() {
  if (GetArena() == nullptr && val_ != nullptr) {
    delete val_;
  }
  val_ = nullptr;
}
inline const ::pg_query::Node& A_Const::_internal_val() const {
  const ::pg_query::Node* p = val_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& A_Const::val() const {
  // @@protoc_insertion_point(field_get:pg_query.A_Const.val)
  return _internal_val();
}
inline void A_Const::unsafe_arena_set_allocated_val(
    ::pg_query::Node* val) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(val_);
  }
  val_ = val;
  if (val) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Const.val)
}
inline ::pg_query::Node* A_Const::release_val() {
  
  ::pg_query::Node* temp = val_;
  val_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* A_Const::unsafe_arena_release_val() {
  // @@protoc_insertion_point(field_release:pg_query.A_Const.val)
  
  ::pg_query::Node* temp = val_;
  val_ = nullptr;
  return temp;
}
inline ::pg_query::Node* A_Const::_internal_mutable_val() {
  
  if (val_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    val_ = p;
  }
  return val_;
}
inline ::pg_query::Node* A_Const::mutable_val() {
  // @@protoc_insertion_point(field_mutable:pg_query.A_Const.val)
  return _internal_mutable_val();
}
inline void A_Const::set_allocated_val(::pg_query::Node* val) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete val_;
  }
  if (val) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(val);
    if (message_arena != submessage_arena) {
      val = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, val, submessage_arena);
    }
    
  } else {
    
  }
  val_ = val;
  // @@protoc_insertion_point(field_set_allocated:pg_query.A_Const.val)
}

// int32 location = 2 [json_name = "location"];
inline void A_Const::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 A_Const::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 A_Const::location() const {
  // @@protoc_insertion_point(field_get:pg_query.A_Const.location)
  return _internal_location();
}
inline void A_Const::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void A_Const::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.A_Const.location)
}

// -------------------------------------------------------------------

// FuncCall

// repeated .pg_query.Node funcname = 1 [json_name = "funcname"];
inline int FuncCall::_internal_funcname_size() const {
  return funcname_.size();
}
inline int FuncCall::funcname_size() const {
  return _internal_funcname_size();
}
inline void FuncCall::clear_funcname() {
  funcname_.Clear();
}
inline ::pg_query::Node* FuncCall::mutable_funcname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.FuncCall.funcname)
  return funcname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
FuncCall::mutable_funcname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FuncCall.funcname)
  return &funcname_;
}
inline const ::pg_query::Node& FuncCall::_internal_funcname(int index) const {
  return funcname_.Get(index);
}
inline const ::pg_query::Node& FuncCall::funcname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.funcname)
  return _internal_funcname(index);
}
inline ::pg_query::Node* FuncCall::_internal_add_funcname() {
  return funcname_.Add();
}
inline ::pg_query::Node* FuncCall::add_funcname() {
  // @@protoc_insertion_point(field_add:pg_query.FuncCall.funcname)
  return _internal_add_funcname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
FuncCall::funcname() const {
  // @@protoc_insertion_point(field_list:pg_query.FuncCall.funcname)
  return funcname_;
}

// repeated .pg_query.Node args = 2 [json_name = "args"];
inline int FuncCall::_internal_args_size() const {
  return args_.size();
}
inline int FuncCall::args_size() const {
  return _internal_args_size();
}
inline void FuncCall::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* FuncCall::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.FuncCall.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
FuncCall::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FuncCall.args)
  return &args_;
}
inline const ::pg_query::Node& FuncCall::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& FuncCall::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.args)
  return _internal_args(index);
}
inline ::pg_query::Node* FuncCall::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* FuncCall::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.FuncCall.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
FuncCall::args() const {
  // @@protoc_insertion_point(field_list:pg_query.FuncCall.args)
  return args_;
}

// repeated .pg_query.Node agg_order = 3 [json_name = "agg_order"];
inline int FuncCall::_internal_agg_order_size() const {
  return agg_order_.size();
}
inline int FuncCall::agg_order_size() const {
  return _internal_agg_order_size();
}
inline void FuncCall::clear_agg_order() {
  agg_order_.Clear();
}
inline ::pg_query::Node* FuncCall::mutable_agg_order(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.FuncCall.agg_order)
  return agg_order_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
FuncCall::mutable_agg_order() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FuncCall.agg_order)
  return &agg_order_;
}
inline const ::pg_query::Node& FuncCall::_internal_agg_order(int index) const {
  return agg_order_.Get(index);
}
inline const ::pg_query::Node& FuncCall::agg_order(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.agg_order)
  return _internal_agg_order(index);
}
inline ::pg_query::Node* FuncCall::_internal_add_agg_order() {
  return agg_order_.Add();
}
inline ::pg_query::Node* FuncCall::add_agg_order() {
  // @@protoc_insertion_point(field_add:pg_query.FuncCall.agg_order)
  return _internal_add_agg_order();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
FuncCall::agg_order() const {
  // @@protoc_insertion_point(field_list:pg_query.FuncCall.agg_order)
  return agg_order_;
}

// .pg_query.Node agg_filter = 4 [json_name = "agg_filter"];
inline bool FuncCall::_internal_has_agg_filter() const {
  return this != internal_default_instance() && agg_filter_ != nullptr;
}
inline bool FuncCall::has_agg_filter() const {
  return _internal_has_agg_filter();
}
inline void FuncCall::clear_agg_filter() {
  if (GetArena() == nullptr && agg_filter_ != nullptr) {
    delete agg_filter_;
  }
  agg_filter_ = nullptr;
}
inline const ::pg_query::Node& FuncCall::_internal_agg_filter() const {
  const ::pg_query::Node* p = agg_filter_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FuncCall::agg_filter() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.agg_filter)
  return _internal_agg_filter();
}
inline void FuncCall::unsafe_arena_set_allocated_agg_filter(
    ::pg_query::Node* agg_filter) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(agg_filter_);
  }
  agg_filter_ = agg_filter;
  if (agg_filter) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FuncCall.agg_filter)
}
inline ::pg_query::Node* FuncCall::release_agg_filter() {
  
  ::pg_query::Node* temp = agg_filter_;
  agg_filter_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* FuncCall::unsafe_arena_release_agg_filter() {
  // @@protoc_insertion_point(field_release:pg_query.FuncCall.agg_filter)
  
  ::pg_query::Node* temp = agg_filter_;
  agg_filter_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FuncCall::_internal_mutable_agg_filter() {
  
  if (agg_filter_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    agg_filter_ = p;
  }
  return agg_filter_;
}
inline ::pg_query::Node* FuncCall::mutable_agg_filter() {
  // @@protoc_insertion_point(field_mutable:pg_query.FuncCall.agg_filter)
  return _internal_mutable_agg_filter();
}
inline void FuncCall::set_allocated_agg_filter(::pg_query::Node* agg_filter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete agg_filter_;
  }
  if (agg_filter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(agg_filter);
    if (message_arena != submessage_arena) {
      agg_filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, agg_filter, submessage_arena);
    }
    
  } else {
    
  }
  agg_filter_ = agg_filter;
  // @@protoc_insertion_point(field_set_allocated:pg_query.FuncCall.agg_filter)
}

// bool agg_within_group = 5 [json_name = "agg_within_group"];
inline void FuncCall::clear_agg_within_group() {
  agg_within_group_ = false;
}
inline bool FuncCall::_internal_agg_within_group() const {
  return agg_within_group_;
}
inline bool FuncCall::agg_within_group() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.agg_within_group)
  return _internal_agg_within_group();
}
inline void FuncCall::_internal_set_agg_within_group(bool value) {
  
  agg_within_group_ = value;
}
inline void FuncCall::set_agg_within_group(bool value) {
  _internal_set_agg_within_group(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncCall.agg_within_group)
}

// bool agg_star = 6 [json_name = "agg_star"];
inline void FuncCall::clear_agg_star() {
  agg_star_ = false;
}
inline bool FuncCall::_internal_agg_star() const {
  return agg_star_;
}
inline bool FuncCall::agg_star() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.agg_star)
  return _internal_agg_star();
}
inline void FuncCall::_internal_set_agg_star(bool value) {
  
  agg_star_ = value;
}
inline void FuncCall::set_agg_star(bool value) {
  _internal_set_agg_star(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncCall.agg_star)
}

// bool agg_distinct = 7 [json_name = "agg_distinct"];
inline void FuncCall::clear_agg_distinct() {
  agg_distinct_ = false;
}
inline bool FuncCall::_internal_agg_distinct() const {
  return agg_distinct_;
}
inline bool FuncCall::agg_distinct() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.agg_distinct)
  return _internal_agg_distinct();
}
inline void FuncCall::_internal_set_agg_distinct(bool value) {
  
  agg_distinct_ = value;
}
inline void FuncCall::set_agg_distinct(bool value) {
  _internal_set_agg_distinct(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncCall.agg_distinct)
}

// bool func_variadic = 8 [json_name = "func_variadic"];
inline void FuncCall::clear_func_variadic() {
  func_variadic_ = false;
}
inline bool FuncCall::_internal_func_variadic() const {
  return func_variadic_;
}
inline bool FuncCall::func_variadic() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.func_variadic)
  return _internal_func_variadic();
}
inline void FuncCall::_internal_set_func_variadic(bool value) {
  
  func_variadic_ = value;
}
inline void FuncCall::set_func_variadic(bool value) {
  _internal_set_func_variadic(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncCall.func_variadic)
}

// .pg_query.WindowDef over = 9 [json_name = "over"];
inline bool FuncCall::_internal_has_over() const {
  return this != internal_default_instance() && over_ != nullptr;
}
inline bool FuncCall::has_over() const {
  return _internal_has_over();
}
inline void FuncCall::clear_over() {
  if (GetArena() == nullptr && over_ != nullptr) {
    delete over_;
  }
  over_ = nullptr;
}
inline const ::pg_query::WindowDef& FuncCall::_internal_over() const {
  const ::pg_query::WindowDef* p = over_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::WindowDef&>(
      ::pg_query::_WindowDef_default_instance_);
}
inline const ::pg_query::WindowDef& FuncCall::over() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.over)
  return _internal_over();
}
inline void FuncCall::unsafe_arena_set_allocated_over(
    ::pg_query::WindowDef* over) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(over_);
  }
  over_ = over;
  if (over) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FuncCall.over)
}
inline ::pg_query::WindowDef* FuncCall::release_over() {
  
  ::pg_query::WindowDef* temp = over_;
  over_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::WindowDef* FuncCall::unsafe_arena_release_over() {
  // @@protoc_insertion_point(field_release:pg_query.FuncCall.over)
  
  ::pg_query::WindowDef* temp = over_;
  over_ = nullptr;
  return temp;
}
inline ::pg_query::WindowDef* FuncCall::_internal_mutable_over() {
  
  if (over_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::WindowDef>(GetArena());
    over_ = p;
  }
  return over_;
}
inline ::pg_query::WindowDef* FuncCall::mutable_over() {
  // @@protoc_insertion_point(field_mutable:pg_query.FuncCall.over)
  return _internal_mutable_over();
}
inline void FuncCall::set_allocated_over(::pg_query::WindowDef* over) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete over_;
  }
  if (over) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(over);
    if (message_arena != submessage_arena) {
      over = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, over, submessage_arena);
    }
    
  } else {
    
  }
  over_ = over;
  // @@protoc_insertion_point(field_set_allocated:pg_query.FuncCall.over)
}

// int32 location = 10 [json_name = "location"];
inline void FuncCall::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FuncCall::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FuncCall::location() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.location)
  return _internal_location();
}
inline void FuncCall::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void FuncCall::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncCall.location)
}

// -------------------------------------------------------------------

// A_Star

// -------------------------------------------------------------------

// A_Indices

// bool is_slice = 1 [json_name = "is_slice"];
inline void A_Indices::clear_is_slice() {
  is_slice_ = false;
}
inline bool A_Indices::_internal_is_slice() const {
  return is_slice_;
}
inline bool A_Indices::is_slice() const {
  // @@protoc_insertion_point(field_get:pg_query.A_Indices.is_slice)
  return _internal_is_slice();
}
inline void A_Indices::_internal_set_is_slice(bool value) {
  
  is_slice_ = value;
}
inline void A_Indices::set_is_slice(bool value) {
  _internal_set_is_slice(value);
  // @@protoc_insertion_point(field_set:pg_query.A_Indices.is_slice)
}

// .pg_query.Node lidx = 2 [json_name = "lidx"];
inline bool A_Indices::_internal_has_lidx() const {
  return this != internal_default_instance() && lidx_ != nullptr;
}
inline bool A_Indices::has_lidx() const {
  return _internal_has_lidx();
}
inline void A_Indices::clear_lidx() {
  if (GetArena() == nullptr && lidx_ != nullptr) {
    delete lidx_;
  }
  lidx_ = nullptr;
}
inline const ::pg_query::Node& A_Indices::_internal_lidx() const {
  const ::pg_query::Node* p = lidx_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& A_Indices::lidx() const {
  // @@protoc_insertion_point(field_get:pg_query.A_Indices.lidx)
  return _internal_lidx();
}
inline void A_Indices::unsafe_arena_set_allocated_lidx(
    ::pg_query::Node* lidx) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lidx_);
  }
  lidx_ = lidx;
  if (lidx) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Indices.lidx)
}
inline ::pg_query::Node* A_Indices::release_lidx() {
  
  ::pg_query::Node* temp = lidx_;
  lidx_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* A_Indices::unsafe_arena_release_lidx() {
  // @@protoc_insertion_point(field_release:pg_query.A_Indices.lidx)
  
  ::pg_query::Node* temp = lidx_;
  lidx_ = nullptr;
  return temp;
}
inline ::pg_query::Node* A_Indices::_internal_mutable_lidx() {
  
  if (lidx_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    lidx_ = p;
  }
  return lidx_;
}
inline ::pg_query::Node* A_Indices::mutable_lidx() {
  // @@protoc_insertion_point(field_mutable:pg_query.A_Indices.lidx)
  return _internal_mutable_lidx();
}
inline void A_Indices::set_allocated_lidx(::pg_query::Node* lidx) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete lidx_;
  }
  if (lidx) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(lidx);
    if (message_arena != submessage_arena) {
      lidx = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lidx, submessage_arena);
    }
    
  } else {
    
  }
  lidx_ = lidx;
  // @@protoc_insertion_point(field_set_allocated:pg_query.A_Indices.lidx)
}

// .pg_query.Node uidx = 3 [json_name = "uidx"];
inline bool A_Indices::_internal_has_uidx() const {
  return this != internal_default_instance() && uidx_ != nullptr;
}
inline bool A_Indices::has_uidx() const {
  return _internal_has_uidx();
}
inline void A_Indices::clear_uidx() {
  if (GetArena() == nullptr && uidx_ != nullptr) {
    delete uidx_;
  }
  uidx_ = nullptr;
}
inline const ::pg_query::Node& A_Indices::_internal_uidx() const {
  const ::pg_query::Node* p = uidx_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& A_Indices::uidx() const {
  // @@protoc_insertion_point(field_get:pg_query.A_Indices.uidx)
  return _internal_uidx();
}
inline void A_Indices::unsafe_arena_set_allocated_uidx(
    ::pg_query::Node* uidx) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(uidx_);
  }
  uidx_ = uidx;
  if (uidx) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Indices.uidx)
}
inline ::pg_query::Node* A_Indices::release_uidx() {
  
  ::pg_query::Node* temp = uidx_;
  uidx_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* A_Indices::unsafe_arena_release_uidx() {
  // @@protoc_insertion_point(field_release:pg_query.A_Indices.uidx)
  
  ::pg_query::Node* temp = uidx_;
  uidx_ = nullptr;
  return temp;
}
inline ::pg_query::Node* A_Indices::_internal_mutable_uidx() {
  
  if (uidx_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    uidx_ = p;
  }
  return uidx_;
}
inline ::pg_query::Node* A_Indices::mutable_uidx() {
  // @@protoc_insertion_point(field_mutable:pg_query.A_Indices.uidx)
  return _internal_mutable_uidx();
}
inline void A_Indices::set_allocated_uidx(::pg_query::Node* uidx) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete uidx_;
  }
  if (uidx) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(uidx);
    if (message_arena != submessage_arena) {
      uidx = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, uidx, submessage_arena);
    }
    
  } else {
    
  }
  uidx_ = uidx;
  // @@protoc_insertion_point(field_set_allocated:pg_query.A_Indices.uidx)
}

// -------------------------------------------------------------------

// A_Indirection

// .pg_query.Node arg = 1 [json_name = "arg"];
inline bool A_Indirection::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool A_Indirection::has_arg() const {
  return _internal_has_arg();
}
inline void A_Indirection::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& A_Indirection::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& A_Indirection::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.A_Indirection.arg)
  return _internal_arg();
}
inline void A_Indirection::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Indirection.arg)
}
inline ::pg_query::Node* A_Indirection::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* A_Indirection::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.A_Indirection.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* A_Indirection::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* A_Indirection::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.A_Indirection.arg)
  return _internal_mutable_arg();
}
inline void A_Indirection::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.A_Indirection.arg)
}

// repeated .pg_query.Node indirection = 2 [json_name = "indirection"];
inline int A_Indirection::_internal_indirection_size() const {
  return indirection_.size();
}
inline int A_Indirection::indirection_size() const {
  return _internal_indirection_size();
}
inline void A_Indirection::clear_indirection() {
  indirection_.Clear();
}
inline ::pg_query::Node* A_Indirection::mutable_indirection(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.A_Indirection.indirection)
  return indirection_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
A_Indirection::mutable_indirection() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.A_Indirection.indirection)
  return &indirection_;
}
inline const ::pg_query::Node& A_Indirection::_internal_indirection(int index) const {
  return indirection_.Get(index);
}
inline const ::pg_query::Node& A_Indirection::indirection(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.A_Indirection.indirection)
  return _internal_indirection(index);
}
inline ::pg_query::Node* A_Indirection::_internal_add_indirection() {
  return indirection_.Add();
}
inline ::pg_query::Node* A_Indirection::add_indirection() {
  // @@protoc_insertion_point(field_add:pg_query.A_Indirection.indirection)
  return _internal_add_indirection();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
A_Indirection::indirection() const {
  // @@protoc_insertion_point(field_list:pg_query.A_Indirection.indirection)
  return indirection_;
}

// -------------------------------------------------------------------

// A_ArrayExpr

// repeated .pg_query.Node elements = 1 [json_name = "elements"];
inline int A_ArrayExpr::_internal_elements_size() const {
  return elements_.size();
}
inline int A_ArrayExpr::elements_size() const {
  return _internal_elements_size();
}
inline void A_ArrayExpr::clear_elements() {
  elements_.Clear();
}
inline ::pg_query::Node* A_ArrayExpr::mutable_elements(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.A_ArrayExpr.elements)
  return elements_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
A_ArrayExpr::mutable_elements() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.A_ArrayExpr.elements)
  return &elements_;
}
inline const ::pg_query::Node& A_ArrayExpr::_internal_elements(int index) const {
  return elements_.Get(index);
}
inline const ::pg_query::Node& A_ArrayExpr::elements(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.A_ArrayExpr.elements)
  return _internal_elements(index);
}
inline ::pg_query::Node* A_ArrayExpr::_internal_add_elements() {
  return elements_.Add();
}
inline ::pg_query::Node* A_ArrayExpr::add_elements() {
  // @@protoc_insertion_point(field_add:pg_query.A_ArrayExpr.elements)
  return _internal_add_elements();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
A_ArrayExpr::elements() const {
  // @@protoc_insertion_point(field_list:pg_query.A_ArrayExpr.elements)
  return elements_;
}

// int32 location = 2 [json_name = "location"];
inline void A_ArrayExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 A_ArrayExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 A_ArrayExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.A_ArrayExpr.location)
  return _internal_location();
}
inline void A_ArrayExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void A_ArrayExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.A_ArrayExpr.location)
}

// -------------------------------------------------------------------

// ResTarget

// string name = 1 [json_name = "name"];
inline void ResTarget::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& ResTarget::name() const {
  // @@protoc_insertion_point(field_get:pg_query.ResTarget.name)
  return _internal_name();
}
inline void ResTarget::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.ResTarget.name)
}
inline std::string* ResTarget::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.ResTarget.name)
  return _internal_mutable_name();
}
inline const std::string& ResTarget::_internal_name() const {
  return name_.Get();
}
inline void ResTarget::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ResTarget::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ResTarget.name)
}
inline void ResTarget::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ResTarget.name)
}
inline void ResTarget::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ResTarget.name)
}
inline std::string* ResTarget::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ResTarget::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.ResTarget.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ResTarget::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ResTarget.name)
}

// repeated .pg_query.Node indirection = 2 [json_name = "indirection"];
inline int ResTarget::_internal_indirection_size() const {
  return indirection_.size();
}
inline int ResTarget::indirection_size() const {
  return _internal_indirection_size();
}
inline void ResTarget::clear_indirection() {
  indirection_.Clear();
}
inline ::pg_query::Node* ResTarget::mutable_indirection(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ResTarget.indirection)
  return indirection_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ResTarget::mutable_indirection() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ResTarget.indirection)
  return &indirection_;
}
inline const ::pg_query::Node& ResTarget::_internal_indirection(int index) const {
  return indirection_.Get(index);
}
inline const ::pg_query::Node& ResTarget::indirection(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ResTarget.indirection)
  return _internal_indirection(index);
}
inline ::pg_query::Node* ResTarget::_internal_add_indirection() {
  return indirection_.Add();
}
inline ::pg_query::Node* ResTarget::add_indirection() {
  // @@protoc_insertion_point(field_add:pg_query.ResTarget.indirection)
  return _internal_add_indirection();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ResTarget::indirection() const {
  // @@protoc_insertion_point(field_list:pg_query.ResTarget.indirection)
  return indirection_;
}

// .pg_query.Node val = 3 [json_name = "val"];
inline bool ResTarget::_internal_has_val() const {
  return this != internal_default_instance() && val_ != nullptr;
}
inline bool ResTarget::has_val() const {
  return _internal_has_val();
}
inline void ResTarget::clear_val() {
  if (GetArena() == nullptr && val_ != nullptr) {
    delete val_;
  }
  val_ = nullptr;
}
inline const ::pg_query::Node& ResTarget::_internal_val() const {
  const ::pg_query::Node* p = val_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ResTarget::val() const {
  // @@protoc_insertion_point(field_get:pg_query.ResTarget.val)
  return _internal_val();
}
inline void ResTarget::unsafe_arena_set_allocated_val(
    ::pg_query::Node* val) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(val_);
  }
  val_ = val;
  if (val) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ResTarget.val)
}
inline ::pg_query::Node* ResTarget::release_val() {
  
  ::pg_query::Node* temp = val_;
  val_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* ResTarget::unsafe_arena_release_val() {
  // @@protoc_insertion_point(field_release:pg_query.ResTarget.val)
  
  ::pg_query::Node* temp = val_;
  val_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ResTarget::_internal_mutable_val() {
  
  if (val_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    val_ = p;
  }
  return val_;
}
inline ::pg_query::Node* ResTarget::mutable_val() {
  // @@protoc_insertion_point(field_mutable:pg_query.ResTarget.val)
  return _internal_mutable_val();
}
inline void ResTarget::set_allocated_val(::pg_query::Node* val) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete val_;
  }
  if (val) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(val);
    if (message_arena != submessage_arena) {
      val = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, val, submessage_arena);
    }
    
  } else {
    
  }
  val_ = val;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ResTarget.val)
}

// int32 location = 4 [json_name = "location"];
inline void ResTarget::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ResTarget::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ResTarget::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ResTarget.location)
  return _internal_location();
}
inline void ResTarget::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void ResTarget::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ResTarget.location)
}

// -------------------------------------------------------------------

// MultiAssignRef

// .pg_query.Node source = 1 [json_name = "source"];
inline bool MultiAssignRef::_internal_has_source() const {
  return this != internal_default_instance() && source_ != nullptr;
}
inline bool MultiAssignRef::has_source() const {
  return _internal_has_source();
}
inline void MultiAssignRef::clear_source() {
  if (GetArena() == nullptr && source_ != nullptr) {
    delete source_;
  }
  source_ = nullptr;
}
inline const ::pg_query::Node& MultiAssignRef::_internal_source() const {
  const ::pg_query::Node* p = source_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& MultiAssignRef::source() const {
  // @@protoc_insertion_point(field_get:pg_query.MultiAssignRef.source)
  return _internal_source();
}
inline void MultiAssignRef::unsafe_arena_set_allocated_source(
    ::pg_query::Node* source) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_);
  }
  source_ = source;
  if (source) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MultiAssignRef.source)
}
inline ::pg_query::Node* MultiAssignRef::release_source() {
  
  ::pg_query::Node* temp = source_;
  source_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* MultiAssignRef::unsafe_arena_release_source() {
  // @@protoc_insertion_point(field_release:pg_query.MultiAssignRef.source)
  
  ::pg_query::Node* temp = source_;
  source_ = nullptr;
  return temp;
}
inline ::pg_query::Node* MultiAssignRef::_internal_mutable_source() {
  
  if (source_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    source_ = p;
  }
  return source_;
}
inline ::pg_query::Node* MultiAssignRef::mutable_source() {
  // @@protoc_insertion_point(field_mutable:pg_query.MultiAssignRef.source)
  return _internal_mutable_source();
}
inline void MultiAssignRef::set_allocated_source(::pg_query::Node* source) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete source_;
  }
  if (source) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(source);
    if (message_arena != submessage_arena) {
      source = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, source, submessage_arena);
    }
    
  } else {
    
  }
  source_ = source;
  // @@protoc_insertion_point(field_set_allocated:pg_query.MultiAssignRef.source)
}

// int32 colno = 2 [json_name = "colno"];
inline void MultiAssignRef::clear_colno() {
  colno_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 MultiAssignRef::_internal_colno() const {
  return colno_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 MultiAssignRef::colno() const {
  // @@protoc_insertion_point(field_get:pg_query.MultiAssignRef.colno)
  return _internal_colno();
}
inline void MultiAssignRef::_internal_set_colno(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  colno_ = value;
}
inline void MultiAssignRef::set_colno(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_colno(value);
  // @@protoc_insertion_point(field_set:pg_query.MultiAssignRef.colno)
}

// int32 ncolumns = 3 [json_name = "ncolumns"];
inline void MultiAssignRef::clear_ncolumns() {
  ncolumns_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 MultiAssignRef::_internal_ncolumns() const {
  return ncolumns_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 MultiAssignRef::ncolumns() const {
  // @@protoc_insertion_point(field_get:pg_query.MultiAssignRef.ncolumns)
  return _internal_ncolumns();
}
inline void MultiAssignRef::_internal_set_ncolumns(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  ncolumns_ = value;
}
inline void MultiAssignRef::set_ncolumns(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_ncolumns(value);
  // @@protoc_insertion_point(field_set:pg_query.MultiAssignRef.ncolumns)
}

// -------------------------------------------------------------------

// TypeCast

// .pg_query.Node arg = 1 [json_name = "arg"];
inline bool TypeCast::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool TypeCast::has_arg() const {
  return _internal_has_arg();
}
inline void TypeCast::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& TypeCast::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& TypeCast::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeCast.arg)
  return _internal_arg();
}
inline void TypeCast::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TypeCast.arg)
}
inline ::pg_query::Node* TypeCast::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* TypeCast::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.TypeCast.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* TypeCast::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* TypeCast::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.TypeCast.arg)
  return _internal_mutable_arg();
}
inline void TypeCast::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.TypeCast.arg)
}

// .pg_query.TypeName type_name = 2 [json_name = "typeName"];
inline bool TypeCast::_internal_has_type_name() const {
  return this != internal_default_instance() && type_name_ != nullptr;
}
inline bool TypeCast::has_type_name() const {
  return _internal_has_type_name();
}
inline void TypeCast::clear_type_name() {
  if (GetArena() == nullptr && type_name_ != nullptr) {
    delete type_name_;
  }
  type_name_ = nullptr;
}
inline const ::pg_query::TypeName& TypeCast::_internal_type_name() const {
  const ::pg_query::TypeName* p = type_name_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(
      ::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& TypeCast::type_name() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeCast.type_name)
  return _internal_type_name();
}
inline void TypeCast::unsafe_arena_set_allocated_type_name(
    ::pg_query::TypeName* type_name) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_name_);
  }
  type_name_ = type_name;
  if (type_name) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TypeCast.type_name)
}
inline ::pg_query::TypeName* TypeCast::release_type_name() {
  
  ::pg_query::TypeName* temp = type_name_;
  type_name_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TypeName* TypeCast::unsafe_arena_release_type_name() {
  // @@protoc_insertion_point(field_release:pg_query.TypeCast.type_name)
  
  ::pg_query::TypeName* temp = type_name_;
  type_name_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* TypeCast::_internal_mutable_type_name() {
  
  if (type_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    type_name_ = p;
  }
  return type_name_;
}
inline ::pg_query::TypeName* TypeCast::mutable_type_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.TypeCast.type_name)
  return _internal_mutable_type_name();
}
inline void TypeCast::set_allocated_type_name(::pg_query::TypeName* type_name) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete type_name_;
  }
  if (type_name) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_name);
    if (message_arena != submessage_arena) {
      type_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, type_name, submessage_arena);
    }
    
  } else {
    
  }
  type_name_ = type_name;
  // @@protoc_insertion_point(field_set_allocated:pg_query.TypeCast.type_name)
}

// int32 location = 3 [json_name = "location"];
inline void TypeCast::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TypeCast::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TypeCast::location() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeCast.location)
  return _internal_location();
}
inline void TypeCast::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void TypeCast::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.TypeCast.location)
}

// -------------------------------------------------------------------

// CollateClause

// .pg_query.Node arg = 1 [json_name = "arg"];
inline bool CollateClause::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool CollateClause::has_arg() const {
  return _internal_has_arg();
}
inline void CollateClause::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& CollateClause::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CollateClause::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.CollateClause.arg)
  return _internal_arg();
}
inline void CollateClause::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CollateClause.arg)
}
inline ::pg_query::Node* CollateClause::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CollateClause::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.CollateClause.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CollateClause::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* CollateClause::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.CollateClause.arg)
  return _internal_mutable_arg();
}
inline void CollateClause::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CollateClause.arg)
}

// repeated .pg_query.Node collname = 2 [json_name = "collname"];
inline int CollateClause::_internal_collname_size() const {
  return collname_.size();
}
inline int CollateClause::collname_size() const {
  return _internal_collname_size();
}
inline void CollateClause::clear_collname() {
  collname_.Clear();
}
inline ::pg_query::Node* CollateClause::mutable_collname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CollateClause.collname)
  return collname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CollateClause::mutable_collname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CollateClause.collname)
  return &collname_;
}
inline const ::pg_query::Node& CollateClause::_internal_collname(int index) const {
  return collname_.Get(index);
}
inline const ::pg_query::Node& CollateClause::collname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CollateClause.collname)
  return _internal_collname(index);
}
inline ::pg_query::Node* CollateClause::_internal_add_collname() {
  return collname_.Add();
}
inline ::pg_query::Node* CollateClause::add_collname() {
  // @@protoc_insertion_point(field_add:pg_query.CollateClause.collname)
  return _internal_add_collname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CollateClause::collname() const {
  // @@protoc_insertion_point(field_list:pg_query.CollateClause.collname)
  return collname_;
}

// int32 location = 3 [json_name = "location"];
inline void CollateClause::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CollateClause::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CollateClause::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CollateClause.location)
  return _internal_location();
}
inline void CollateClause::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void CollateClause::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CollateClause.location)
}

// -------------------------------------------------------------------

// SortBy

// .pg_query.Node node = 1 [json_name = "node"];
inline bool SortBy::_internal_has_node() const {
  return this != internal_default_instance() && node_ != nullptr;
}
inline bool SortBy::has_node() const {
  return _internal_has_node();
}
inline void SortBy::clear_node() {
  if (GetArena() == nullptr && node_ != nullptr) {
    delete node_;
  }
  node_ = nullptr;
}
inline const ::pg_query::Node& SortBy::_internal_node() const {
  const ::pg_query::Node* p = node_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SortBy::node() const {
  // @@protoc_insertion_point(field_get:pg_query.SortBy.node)
  return _internal_node();
}
inline void SortBy::unsafe_arena_set_allocated_node(
    ::pg_query::Node* node) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(node_);
  }
  node_ = node;
  if (node) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SortBy.node)
}
inline ::pg_query::Node* SortBy::release_node() {
  
  ::pg_query::Node* temp = node_;
  node_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* SortBy::unsafe_arena_release_node() {
  // @@protoc_insertion_point(field_release:pg_query.SortBy.node)
  
  ::pg_query::Node* temp = node_;
  node_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SortBy::_internal_mutable_node() {
  
  if (node_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    node_ = p;
  }
  return node_;
}
inline ::pg_query::Node* SortBy::mutable_node() {
  // @@protoc_insertion_point(field_mutable:pg_query.SortBy.node)
  return _internal_mutable_node();
}
inline void SortBy::set_allocated_node(::pg_query::Node* node) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete node_;
  }
  if (node) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(node);
    if (message_arena != submessage_arena) {
      node = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, node, submessage_arena);
    }
    
  } else {
    
  }
  node_ = node;
  // @@protoc_insertion_point(field_set_allocated:pg_query.SortBy.node)
}

// .pg_query.SortByDir sortby_dir = 2 [json_name = "sortby_dir"];
inline void SortBy::clear_sortby_dir() {
  sortby_dir_ = 0;
}
inline ::pg_query::SortByDir SortBy::_internal_sortby_dir() const {
  return static_cast< ::pg_query::SortByDir >(sortby_dir_);
}
inline ::pg_query::SortByDir SortBy::sortby_dir() const {
  // @@protoc_insertion_point(field_get:pg_query.SortBy.sortby_dir)
  return _internal_sortby_dir();
}
inline void SortBy::_internal_set_sortby_dir(::pg_query::SortByDir value) {
  
  sortby_dir_ = value;
}
inline void SortBy::set_sortby_dir(::pg_query::SortByDir value) {
  _internal_set_sortby_dir(value);
  // @@protoc_insertion_point(field_set:pg_query.SortBy.sortby_dir)
}

// .pg_query.SortByNulls sortby_nulls = 3 [json_name = "sortby_nulls"];
inline void SortBy::clear_sortby_nulls() {
  sortby_nulls_ = 0;
}
inline ::pg_query::SortByNulls SortBy::_internal_sortby_nulls() const {
  return static_cast< ::pg_query::SortByNulls >(sortby_nulls_);
}
inline ::pg_query::SortByNulls SortBy::sortby_nulls() const {
  // @@protoc_insertion_point(field_get:pg_query.SortBy.sortby_nulls)
  return _internal_sortby_nulls();
}
inline void SortBy::_internal_set_sortby_nulls(::pg_query::SortByNulls value) {
  
  sortby_nulls_ = value;
}
inline void SortBy::set_sortby_nulls(::pg_query::SortByNulls value) {
  _internal_set_sortby_nulls(value);
  // @@protoc_insertion_point(field_set:pg_query.SortBy.sortby_nulls)
}

// repeated .pg_query.Node use_op = 4 [json_name = "useOp"];
inline int SortBy::_internal_use_op_size() const {
  return use_op_.size();
}
inline int SortBy::use_op_size() const {
  return _internal_use_op_size();
}
inline void SortBy::clear_use_op() {
  use_op_.Clear();
}
inline ::pg_query::Node* SortBy::mutable_use_op(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.SortBy.use_op)
  return use_op_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
SortBy::mutable_use_op() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SortBy.use_op)
  return &use_op_;
}
inline const ::pg_query::Node& SortBy::_internal_use_op(int index) const {
  return use_op_.Get(index);
}
inline const ::pg_query::Node& SortBy::use_op(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.SortBy.use_op)
  return _internal_use_op(index);
}
inline ::pg_query::Node* SortBy::_internal_add_use_op() {
  return use_op_.Add();
}
inline ::pg_query::Node* SortBy::add_use_op() {
  // @@protoc_insertion_point(field_add:pg_query.SortBy.use_op)
  return _internal_add_use_op();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
SortBy::use_op() const {
  // @@protoc_insertion_point(field_list:pg_query.SortBy.use_op)
  return use_op_;
}

// int32 location = 5 [json_name = "location"];
inline void SortBy::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SortBy::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SortBy::location() const {
  // @@protoc_insertion_point(field_get:pg_query.SortBy.location)
  return _internal_location();
}
inline void SortBy::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void SortBy::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.SortBy.location)
}

// -------------------------------------------------------------------

// WindowDef

// string name = 1 [json_name = "name"];
inline void WindowDef::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& WindowDef::name() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.name)
  return _internal_name();
}
inline void WindowDef::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowDef.name)
}
inline std::string* WindowDef::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.name)
  return _internal_mutable_name();
}
inline const std::string& WindowDef::_internal_name() const {
  return name_.Get();
}
inline void WindowDef::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void WindowDef::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.WindowDef.name)
}
inline void WindowDef::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.WindowDef.name)
}
inline void WindowDef::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.WindowDef.name)
}
inline std::string* WindowDef::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WindowDef::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.WindowDef.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void WindowDef::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowDef.name)
}

// string refname = 2 [json_name = "refname"];
inline void WindowDef::clear_refname() {
  refname_.ClearToEmpty();
}
inline const std::string& WindowDef::refname() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.refname)
  return _internal_refname();
}
inline void WindowDef::set_refname(const std::string& value) {
  _internal_set_refname(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowDef.refname)
}
inline std::string* WindowDef::mutable_refname() {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.refname)
  return _internal_mutable_refname();
}
inline const std::string& WindowDef::_internal_refname() const {
  return refname_.Get();
}
inline void WindowDef::_internal_set_refname(const std::string& value) {
  
  refname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void WindowDef::set_refname(std::string&& value) {
  
  refname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.WindowDef.refname)
}
inline void WindowDef::set_refname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  refname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.WindowDef.refname)
}
inline void WindowDef::set_refname(const char* value,
    size_t size) {
  
  refname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.WindowDef.refname)
}
inline std::string* WindowDef::_internal_mutable_refname() {
  
  return refname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WindowDef::release_refname() {
  // @@protoc_insertion_point(field_release:pg_query.WindowDef.refname)
  return refname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void WindowDef::set_allocated_refname(std::string* refname) {
  if (refname != nullptr) {
    
  } else {
    
  }
  refname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), refname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowDef.refname)
}

// repeated .pg_query.Node partition_clause = 3 [json_name = "partitionClause"];
inline int WindowDef::_internal_partition_clause_size() const {
  return partition_clause_.size();
}
inline int WindowDef::partition_clause_size() const {
  return _internal_partition_clause_size();
}
inline void WindowDef::clear_partition_clause() {
  partition_clause_.Clear();
}
inline ::pg_query::Node* WindowDef::mutable_partition_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.partition_clause)
  return partition_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
WindowDef::mutable_partition_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.WindowDef.partition_clause)
  return &partition_clause_;
}
inline const ::pg_query::Node& WindowDef::_internal_partition_clause(int index) const {
  return partition_clause_.Get(index);
}
inline const ::pg_query::Node& WindowDef::partition_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.partition_clause)
  return _internal_partition_clause(index);
}
inline ::pg_query::Node* WindowDef::_internal_add_partition_clause() {
  return partition_clause_.Add();
}
inline ::pg_query::Node* WindowDef::add_partition_clause() {
  // @@protoc_insertion_point(field_add:pg_query.WindowDef.partition_clause)
  return _internal_add_partition_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
WindowDef::partition_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.WindowDef.partition_clause)
  return partition_clause_;
}

// repeated .pg_query.Node order_clause = 4 [json_name = "orderClause"];
inline int WindowDef::_internal_order_clause_size() const {
  return order_clause_.size();
}
inline int WindowDef::order_clause_size() const {
  return _internal_order_clause_size();
}
inline void WindowDef::clear_order_clause() {
  order_clause_.Clear();
}
inline ::pg_query::Node* WindowDef::mutable_order_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.order_clause)
  return order_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
WindowDef::mutable_order_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.WindowDef.order_clause)
  return &order_clause_;
}
inline const ::pg_query::Node& WindowDef::_internal_order_clause(int index) const {
  return order_clause_.Get(index);
}
inline const ::pg_query::Node& WindowDef::order_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.order_clause)
  return _internal_order_clause(index);
}
inline ::pg_query::Node* WindowDef::_internal_add_order_clause() {
  return order_clause_.Add();
}
inline ::pg_query::Node* WindowDef::add_order_clause() {
  // @@protoc_insertion_point(field_add:pg_query.WindowDef.order_clause)
  return _internal_add_order_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
WindowDef::order_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.WindowDef.order_clause)
  return order_clause_;
}

// int32 frame_options = 5 [json_name = "frameOptions"];
inline void WindowDef::clear_frame_options() {
  frame_options_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 WindowDef::_internal_frame_options() const {
  return frame_options_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 WindowDef::frame_options() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.frame_options)
  return _internal_frame_options();
}
inline void WindowDef::_internal_set_frame_options(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  frame_options_ = value;
}
inline void WindowDef::set_frame_options(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_frame_options(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowDef.frame_options)
}

// .pg_query.Node start_offset = 6 [json_name = "startOffset"];
inline bool WindowDef::_internal_has_start_offset() const {
  return this != internal_default_instance() && start_offset_ != nullptr;
}
inline bool WindowDef::has_start_offset() const {
  return _internal_has_start_offset();
}
inline void WindowDef::clear_start_offset() {
  if (GetArena() == nullptr && start_offset_ != nullptr) {
    delete start_offset_;
  }
  start_offset_ = nullptr;
}
inline const ::pg_query::Node& WindowDef::_internal_start_offset() const {
  const ::pg_query::Node* p = start_offset_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& WindowDef::start_offset() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.start_offset)
  return _internal_start_offset();
}
inline void WindowDef::unsafe_arena_set_allocated_start_offset(
    ::pg_query::Node* start_offset) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(start_offset_);
  }
  start_offset_ = start_offset;
  if (start_offset) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowDef.start_offset)
}
inline ::pg_query::Node* WindowDef::release_start_offset() {
  
  ::pg_query::Node* temp = start_offset_;
  start_offset_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* WindowDef::unsafe_arena_release_start_offset() {
  // @@protoc_insertion_point(field_release:pg_query.WindowDef.start_offset)
  
  ::pg_query::Node* temp = start_offset_;
  start_offset_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WindowDef::_internal_mutable_start_offset() {
  
  if (start_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    start_offset_ = p;
  }
  return start_offset_;
}
inline ::pg_query::Node* WindowDef::mutable_start_offset() {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.start_offset)
  return _internal_mutable_start_offset();
}
inline void WindowDef::set_allocated_start_offset(::pg_query::Node* start_offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete start_offset_;
  }
  if (start_offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(start_offset);
    if (message_arena != submessage_arena) {
      start_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, start_offset, submessage_arena);
    }
    
  } else {
    
  }
  start_offset_ = start_offset;
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowDef.start_offset)
}

// .pg_query.Node end_offset = 7 [json_name = "endOffset"];
inline bool WindowDef::_internal_has_end_offset() const {
  return this != internal_default_instance() && end_offset_ != nullptr;
}
inline bool WindowDef::has_end_offset() const {
  return _internal_has_end_offset();
}
inline void WindowDef::clear_end_offset() {
  if (GetArena() == nullptr && end_offset_ != nullptr) {
    delete end_offset_;
  }
  end_offset_ = nullptr;
}
inline const ::pg_query::Node& WindowDef::_internal_end_offset() const {
  const ::pg_query::Node* p = end_offset_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& WindowDef::end_offset() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.end_offset)
  return _internal_end_offset();
}
inline void WindowDef::unsafe_arena_set_allocated_end_offset(
    ::pg_query::Node* end_offset) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(end_offset_);
  }
  end_offset_ = end_offset;
  if (end_offset) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowDef.end_offset)
}
inline ::pg_query::Node* WindowDef::release_end_offset() {
  
  ::pg_query::Node* temp = end_offset_;
  end_offset_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* WindowDef::unsafe_arena_release_end_offset() {
  // @@protoc_insertion_point(field_release:pg_query.WindowDef.end_offset)
  
  ::pg_query::Node* temp = end_offset_;
  end_offset_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WindowDef::_internal_mutable_end_offset() {
  
  if (end_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    end_offset_ = p;
  }
  return end_offset_;
}
inline ::pg_query::Node* WindowDef::mutable_end_offset() {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.end_offset)
  return _internal_mutable_end_offset();
}
inline void WindowDef::set_allocated_end_offset(::pg_query::Node* end_offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete end_offset_;
  }
  if (end_offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(end_offset);
    if (message_arena != submessage_arena) {
      end_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, end_offset, submessage_arena);
    }
    
  } else {
    
  }
  end_offset_ = end_offset;
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowDef.end_offset)
}

// int32 location = 8 [json_name = "location"];
inline void WindowDef::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 WindowDef::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 WindowDef::location() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.location)
  return _internal_location();
}
inline void WindowDef::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void WindowDef::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowDef.location)
}

// -------------------------------------------------------------------

// RangeSubselect

// bool lateral = 1 [json_name = "lateral"];
inline void RangeSubselect::clear_lateral() {
  lateral_ = false;
}
inline bool RangeSubselect::_internal_lateral() const {
  return lateral_;
}
inline bool RangeSubselect::lateral() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeSubselect.lateral)
  return _internal_lateral();
}
inline void RangeSubselect::_internal_set_lateral(bool value) {
  
  lateral_ = value;
}
inline void RangeSubselect::set_lateral(bool value) {
  _internal_set_lateral(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeSubselect.lateral)
}

// .pg_query.Node subquery = 2 [json_name = "subquery"];
inline bool RangeSubselect::_internal_has_subquery() const {
  return this != internal_default_instance() && subquery_ != nullptr;
}
inline bool RangeSubselect::has_subquery() const {
  return _internal_has_subquery();
}
inline void RangeSubselect::clear_subquery() {
  if (GetArena() == nullptr && subquery_ != nullptr) {
    delete subquery_;
  }
  subquery_ = nullptr;
}
inline const ::pg_query::Node& RangeSubselect::_internal_subquery() const {
  const ::pg_query::Node* p = subquery_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeSubselect::subquery() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeSubselect.subquery)
  return _internal_subquery();
}
inline void RangeSubselect::unsafe_arena_set_allocated_subquery(
    ::pg_query::Node* subquery) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(subquery_);
  }
  subquery_ = subquery;
  if (subquery) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeSubselect.subquery)
}
inline ::pg_query::Node* RangeSubselect::release_subquery() {
  
  ::pg_query::Node* temp = subquery_;
  subquery_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RangeSubselect::unsafe_arena_release_subquery() {
  // @@protoc_insertion_point(field_release:pg_query.RangeSubselect.subquery)
  
  ::pg_query::Node* temp = subquery_;
  subquery_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeSubselect::_internal_mutable_subquery() {
  
  if (subquery_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    subquery_ = p;
  }
  return subquery_;
}
inline ::pg_query::Node* RangeSubselect::mutable_subquery() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeSubselect.subquery)
  return _internal_mutable_subquery();
}
inline void RangeSubselect::set_allocated_subquery(::pg_query::Node* subquery) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete subquery_;
  }
  if (subquery) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(subquery);
    if (message_arena != submessage_arena) {
      subquery = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, subquery, submessage_arena);
    }
    
  } else {
    
  }
  subquery_ = subquery;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeSubselect.subquery)
}

// .pg_query.Alias alias = 3 [json_name = "alias"];
inline bool RangeSubselect::_internal_has_alias() const {
  return this != internal_default_instance() && alias_ != nullptr;
}
inline bool RangeSubselect::has_alias() const {
  return _internal_has_alias();
}
inline void RangeSubselect::clear_alias() {
  if (GetArena() == nullptr && alias_ != nullptr) {
    delete alias_;
  }
  alias_ = nullptr;
}
inline const ::pg_query::Alias& RangeSubselect::_internal_alias() const {
  const ::pg_query::Alias* p = alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(
      ::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& RangeSubselect::alias() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeSubselect.alias)
  return _internal_alias();
}
inline void RangeSubselect::unsafe_arena_set_allocated_alias(
    ::pg_query::Alias* alias) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alias_);
  }
  alias_ = alias;
  if (alias) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeSubselect.alias)
}
inline ::pg_query::Alias* RangeSubselect::release_alias() {
  
  ::pg_query::Alias* temp = alias_;
  alias_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Alias* RangeSubselect::unsafe_arena_release_alias() {
  // @@protoc_insertion_point(field_release:pg_query.RangeSubselect.alias)
  
  ::pg_query::Alias* temp = alias_;
  alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* RangeSubselect::_internal_mutable_alias() {
  
  if (alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    alias_ = p;
  }
  return alias_;
}
inline ::pg_query::Alias* RangeSubselect::mutable_alias() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeSubselect.alias)
  return _internal_mutable_alias();
}
inline void RangeSubselect::set_allocated_alias(::pg_query::Alias* alias) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete alias_;
  }
  if (alias) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(alias);
    if (message_arena != submessage_arena) {
      alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, alias, submessage_arena);
    }
    
  } else {
    
  }
  alias_ = alias;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeSubselect.alias)
}

// -------------------------------------------------------------------

// RangeFunction

// bool lateral = 1 [json_name = "lateral"];
inline void RangeFunction::clear_lateral() {
  lateral_ = false;
}
inline bool RangeFunction::_internal_lateral() const {
  return lateral_;
}
inline bool RangeFunction::lateral() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeFunction.lateral)
  return _internal_lateral();
}
inline void RangeFunction::_internal_set_lateral(bool value) {
  
  lateral_ = value;
}
inline void RangeFunction::set_lateral(bool value) {
  _internal_set_lateral(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeFunction.lateral)
}

// bool ordinality = 2 [json_name = "ordinality"];
inline void RangeFunction::clear_ordinality() {
  ordinality_ = false;
}
inline bool RangeFunction::_internal_ordinality() const {
  return ordinality_;
}
inline bool RangeFunction::ordinality() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeFunction.ordinality)
  return _internal_ordinality();
}
inline void RangeFunction::_internal_set_ordinality(bool value) {
  
  ordinality_ = value;
}
inline void RangeFunction::set_ordinality(bool value) {
  _internal_set_ordinality(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeFunction.ordinality)
}

// bool is_rowsfrom = 3 [json_name = "is_rowsfrom"];
inline void RangeFunction::clear_is_rowsfrom() {
  is_rowsfrom_ = false;
}
inline bool RangeFunction::_internal_is_rowsfrom() const {
  return is_rowsfrom_;
}
inline bool RangeFunction::is_rowsfrom() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeFunction.is_rowsfrom)
  return _internal_is_rowsfrom();
}
inline void RangeFunction::_internal_set_is_rowsfrom(bool value) {
  
  is_rowsfrom_ = value;
}
inline void RangeFunction::set_is_rowsfrom(bool value) {
  _internal_set_is_rowsfrom(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeFunction.is_rowsfrom)
}

// repeated .pg_query.Node functions = 4 [json_name = "functions"];
inline int RangeFunction::_internal_functions_size() const {
  return functions_.size();
}
inline int RangeFunction::functions_size() const {
  return _internal_functions_size();
}
inline void RangeFunction::clear_functions() {
  functions_.Clear();
}
inline ::pg_query::Node* RangeFunction::mutable_functions(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeFunction.functions)
  return functions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeFunction::mutable_functions() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeFunction.functions)
  return &functions_;
}
inline const ::pg_query::Node& RangeFunction::_internal_functions(int index) const {
  return functions_.Get(index);
}
inline const ::pg_query::Node& RangeFunction::functions(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeFunction.functions)
  return _internal_functions(index);
}
inline ::pg_query::Node* RangeFunction::_internal_add_functions() {
  return functions_.Add();
}
inline ::pg_query::Node* RangeFunction::add_functions() {
  // @@protoc_insertion_point(field_add:pg_query.RangeFunction.functions)
  return _internal_add_functions();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeFunction::functions() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeFunction.functions)
  return functions_;
}

// .pg_query.Alias alias = 5 [json_name = "alias"];
inline bool RangeFunction::_internal_has_alias() const {
  return this != internal_default_instance() && alias_ != nullptr;
}
inline bool RangeFunction::has_alias() const {
  return _internal_has_alias();
}
inline void RangeFunction::clear_alias() {
  if (GetArena() == nullptr && alias_ != nullptr) {
    delete alias_;
  }
  alias_ = nullptr;
}
inline const ::pg_query::Alias& RangeFunction::_internal_alias() const {
  const ::pg_query::Alias* p = alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(
      ::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& RangeFunction::alias() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeFunction.alias)
  return _internal_alias();
}
inline void RangeFunction::unsafe_arena_set_allocated_alias(
    ::pg_query::Alias* alias) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alias_);
  }
  alias_ = alias;
  if (alias) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeFunction.alias)
}
inline ::pg_query::Alias* RangeFunction::release_alias() {
  
  ::pg_query::Alias* temp = alias_;
  alias_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Alias* RangeFunction::unsafe_arena_release_alias() {
  // @@protoc_insertion_point(field_release:pg_query.RangeFunction.alias)
  
  ::pg_query::Alias* temp = alias_;
  alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* RangeFunction::_internal_mutable_alias() {
  
  if (alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    alias_ = p;
  }
  return alias_;
}
inline ::pg_query::Alias* RangeFunction::mutable_alias() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeFunction.alias)
  return _internal_mutable_alias();
}
inline void RangeFunction::set_allocated_alias(::pg_query::Alias* alias) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete alias_;
  }
  if (alias) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(alias);
    if (message_arena != submessage_arena) {
      alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, alias, submessage_arena);
    }
    
  } else {
    
  }
  alias_ = alias;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeFunction.alias)
}

// repeated .pg_query.Node coldeflist = 6 [json_name = "coldeflist"];
inline int RangeFunction::_internal_coldeflist_size() const {
  return coldeflist_.size();
}
inline int RangeFunction::coldeflist_size() const {
  return _internal_coldeflist_size();
}
inline void RangeFunction::clear_coldeflist() {
  coldeflist_.Clear();
}
inline ::pg_query::Node* RangeFunction::mutable_coldeflist(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeFunction.coldeflist)
  return coldeflist_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeFunction::mutable_coldeflist() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeFunction.coldeflist)
  return &coldeflist_;
}
inline const ::pg_query::Node& RangeFunction::_internal_coldeflist(int index) const {
  return coldeflist_.Get(index);
}
inline const ::pg_query::Node& RangeFunction::coldeflist(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeFunction.coldeflist)
  return _internal_coldeflist(index);
}
inline ::pg_query::Node* RangeFunction::_internal_add_coldeflist() {
  return coldeflist_.Add();
}
inline ::pg_query::Node* RangeFunction::add_coldeflist() {
  // @@protoc_insertion_point(field_add:pg_query.RangeFunction.coldeflist)
  return _internal_add_coldeflist();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeFunction::coldeflist() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeFunction.coldeflist)
  return coldeflist_;
}

// -------------------------------------------------------------------

// RangeTableSample

// .pg_query.Node relation = 1 [json_name = "relation"];
inline bool RangeTableSample::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool RangeTableSample::has_relation() const {
  return _internal_has_relation();
}
inline void RangeTableSample::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::Node& RangeTableSample::_internal_relation() const {
  const ::pg_query::Node* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTableSample::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.relation)
  return _internal_relation();
}
inline void RangeTableSample::unsafe_arena_set_allocated_relation(
    ::pg_query::Node* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableSample.relation)
}
inline ::pg_query::Node* RangeTableSample::release_relation() {
  
  ::pg_query::Node* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RangeTableSample::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTableSample.relation)
  
  ::pg_query::Node* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTableSample::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::Node* RangeTableSample::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableSample.relation)
  return _internal_mutable_relation();
}
inline void RangeTableSample::set_allocated_relation(::pg_query::Node* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableSample.relation)
}

// repeated .pg_query.Node method = 2 [json_name = "method"];
inline int RangeTableSample::_internal_method_size() const {
  return method_.size();
}
inline int RangeTableSample::method_size() const {
  return _internal_method_size();
}
inline void RangeTableSample::clear_method() {
  method_.Clear();
}
inline ::pg_query::Node* RangeTableSample::mutable_method(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableSample.method)
  return method_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTableSample::mutable_method() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTableSample.method)
  return &method_;
}
inline const ::pg_query::Node& RangeTableSample::_internal_method(int index) const {
  return method_.Get(index);
}
inline const ::pg_query::Node& RangeTableSample::method(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.method)
  return _internal_method(index);
}
inline ::pg_query::Node* RangeTableSample::_internal_add_method() {
  return method_.Add();
}
inline ::pg_query::Node* RangeTableSample::add_method() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTableSample.method)
  return _internal_add_method();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTableSample::method() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTableSample.method)
  return method_;
}

// repeated .pg_query.Node args = 3 [json_name = "args"];
inline int RangeTableSample::_internal_args_size() const {
  return args_.size();
}
inline int RangeTableSample::args_size() const {
  return _internal_args_size();
}
inline void RangeTableSample::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* RangeTableSample::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableSample.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTableSample::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTableSample.args)
  return &args_;
}
inline const ::pg_query::Node& RangeTableSample::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& RangeTableSample::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.args)
  return _internal_args(index);
}
inline ::pg_query::Node* RangeTableSample::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* RangeTableSample::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTableSample.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTableSample::args() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTableSample.args)
  return args_;
}

// .pg_query.Node repeatable = 4 [json_name = "repeatable"];
inline bool RangeTableSample::_internal_has_repeatable() const {
  return this != internal_default_instance() && repeatable_ != nullptr;
}
inline bool RangeTableSample::has_repeatable() const {
  return _internal_has_repeatable();
}
inline void RangeTableSample::clear_repeatable() {
  if (GetArena() == nullptr && repeatable_ != nullptr) {
    delete repeatable_;
  }
  repeatable_ = nullptr;
}
inline const ::pg_query::Node& RangeTableSample::_internal_repeatable() const {
  const ::pg_query::Node* p = repeatable_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTableSample::repeatable() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.repeatable)
  return _internal_repeatable();
}
inline void RangeTableSample::unsafe_arena_set_allocated_repeatable(
    ::pg_query::Node* repeatable) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(repeatable_);
  }
  repeatable_ = repeatable;
  if (repeatable) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableSample.repeatable)
}
inline ::pg_query::Node* RangeTableSample::release_repeatable() {
  
  ::pg_query::Node* temp = repeatable_;
  repeatable_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RangeTableSample::unsafe_arena_release_repeatable() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTableSample.repeatable)
  
  ::pg_query::Node* temp = repeatable_;
  repeatable_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTableSample::_internal_mutable_repeatable() {
  
  if (repeatable_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    repeatable_ = p;
  }
  return repeatable_;
}
inline ::pg_query::Node* RangeTableSample::mutable_repeatable() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableSample.repeatable)
  return _internal_mutable_repeatable();
}
inline void RangeTableSample::set_allocated_repeatable(::pg_query::Node* repeatable) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete repeatable_;
  }
  if (repeatable) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(repeatable);
    if (message_arena != submessage_arena) {
      repeatable = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, repeatable, submessage_arena);
    }
    
  } else {
    
  }
  repeatable_ = repeatable;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableSample.repeatable)
}

// int32 location = 5 [json_name = "location"];
inline void RangeTableSample::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTableSample::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTableSample::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.location)
  return _internal_location();
}
inline void RangeTableSample::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void RangeTableSample::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTableSample.location)
}

// -------------------------------------------------------------------

// RangeTableFunc

// bool lateral = 1 [json_name = "lateral"];
inline void RangeTableFunc::clear_lateral() {
  lateral_ = false;
}
inline bool RangeTableFunc::_internal_lateral() const {
  return lateral_;
}
inline bool RangeTableFunc::lateral() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.lateral)
  return _internal_lateral();
}
inline void RangeTableFunc::_internal_set_lateral(bool value) {
  
  lateral_ = value;
}
inline void RangeTableFunc::set_lateral(bool value) {
  _internal_set_lateral(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTableFunc.lateral)
}

// .pg_query.Node docexpr = 2 [json_name = "docexpr"];
inline bool RangeTableFunc::_internal_has_docexpr() const {
  return this != internal_default_instance() && docexpr_ != nullptr;
}
inline bool RangeTableFunc::has_docexpr() const {
  return _internal_has_docexpr();
}
inline void RangeTableFunc::clear_docexpr() {
  if (GetArena() == nullptr && docexpr_ != nullptr) {
    delete docexpr_;
  }
  docexpr_ = nullptr;
}
inline const ::pg_query::Node& RangeTableFunc::_internal_docexpr() const {
  const ::pg_query::Node* p = docexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTableFunc::docexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.docexpr)
  return _internal_docexpr();
}
inline void RangeTableFunc::unsafe_arena_set_allocated_docexpr(
    ::pg_query::Node* docexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(docexpr_);
  }
  docexpr_ = docexpr;
  if (docexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFunc.docexpr)
}
inline ::pg_query::Node* RangeTableFunc::release_docexpr() {
  
  ::pg_query::Node* temp = docexpr_;
  docexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RangeTableFunc::unsafe_arena_release_docexpr() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFunc.docexpr)
  
  ::pg_query::Node* temp = docexpr_;
  docexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTableFunc::_internal_mutable_docexpr() {
  
  if (docexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    docexpr_ = p;
  }
  return docexpr_;
}
inline ::pg_query::Node* RangeTableFunc::mutable_docexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFunc.docexpr)
  return _internal_mutable_docexpr();
}
inline void RangeTableFunc::set_allocated_docexpr(::pg_query::Node* docexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete docexpr_;
  }
  if (docexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(docexpr);
    if (message_arena != submessage_arena) {
      docexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, docexpr, submessage_arena);
    }
    
  } else {
    
  }
  docexpr_ = docexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFunc.docexpr)
}

// .pg_query.Node rowexpr = 3 [json_name = "rowexpr"];
inline bool RangeTableFunc::_internal_has_rowexpr() const {
  return this != internal_default_instance() && rowexpr_ != nullptr;
}
inline bool RangeTableFunc::has_rowexpr() const {
  return _internal_has_rowexpr();
}
inline void RangeTableFunc::clear_rowexpr() {
  if (GetArena() == nullptr && rowexpr_ != nullptr) {
    delete rowexpr_;
  }
  rowexpr_ = nullptr;
}
inline const ::pg_query::Node& RangeTableFunc::_internal_rowexpr() const {
  const ::pg_query::Node* p = rowexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTableFunc::rowexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.rowexpr)
  return _internal_rowexpr();
}
inline void RangeTableFunc::unsafe_arena_set_allocated_rowexpr(
    ::pg_query::Node* rowexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rowexpr_);
  }
  rowexpr_ = rowexpr;
  if (rowexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFunc.rowexpr)
}
inline ::pg_query::Node* RangeTableFunc::release_rowexpr() {
  
  ::pg_query::Node* temp = rowexpr_;
  rowexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RangeTableFunc::unsafe_arena_release_rowexpr() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFunc.rowexpr)
  
  ::pg_query::Node* temp = rowexpr_;
  rowexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTableFunc::_internal_mutable_rowexpr() {
  
  if (rowexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    rowexpr_ = p;
  }
  return rowexpr_;
}
inline ::pg_query::Node* RangeTableFunc::mutable_rowexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFunc.rowexpr)
  return _internal_mutable_rowexpr();
}
inline void RangeTableFunc::set_allocated_rowexpr(::pg_query::Node* rowexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete rowexpr_;
  }
  if (rowexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(rowexpr);
    if (message_arena != submessage_arena) {
      rowexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rowexpr, submessage_arena);
    }
    
  } else {
    
  }
  rowexpr_ = rowexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFunc.rowexpr)
}

// repeated .pg_query.Node namespaces = 4 [json_name = "namespaces"];
inline int RangeTableFunc::_internal_namespaces_size() const {
  return namespaces_.size();
}
inline int RangeTableFunc::namespaces_size() const {
  return _internal_namespaces_size();
}
inline void RangeTableFunc::clear_namespaces() {
  namespaces_.Clear();
}
inline ::pg_query::Node* RangeTableFunc::mutable_namespaces(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFunc.namespaces)
  return namespaces_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTableFunc::mutable_namespaces() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTableFunc.namespaces)
  return &namespaces_;
}
inline const ::pg_query::Node& RangeTableFunc::_internal_namespaces(int index) const {
  return namespaces_.Get(index);
}
inline const ::pg_query::Node& RangeTableFunc::namespaces(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.namespaces)
  return _internal_namespaces(index);
}
inline ::pg_query::Node* RangeTableFunc::_internal_add_namespaces() {
  return namespaces_.Add();
}
inline ::pg_query::Node* RangeTableFunc::add_namespaces() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTableFunc.namespaces)
  return _internal_add_namespaces();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTableFunc::namespaces() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTableFunc.namespaces)
  return namespaces_;
}

// repeated .pg_query.Node columns = 5 [json_name = "columns"];
inline int RangeTableFunc::_internal_columns_size() const {
  return columns_.size();
}
inline int RangeTableFunc::columns_size() const {
  return _internal_columns_size();
}
inline void RangeTableFunc::clear_columns() {
  columns_.Clear();
}
inline ::pg_query::Node* RangeTableFunc::mutable_columns(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFunc.columns)
  return columns_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTableFunc::mutable_columns() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTableFunc.columns)
  return &columns_;
}
inline const ::pg_query::Node& RangeTableFunc::_internal_columns(int index) const {
  return columns_.Get(index);
}
inline const ::pg_query::Node& RangeTableFunc::columns(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.columns)
  return _internal_columns(index);
}
inline ::pg_query::Node* RangeTableFunc::_internal_add_columns() {
  return columns_.Add();
}
inline ::pg_query::Node* RangeTableFunc::add_columns() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTableFunc.columns)
  return _internal_add_columns();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTableFunc::columns() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTableFunc.columns)
  return columns_;
}

// .pg_query.Alias alias = 6 [json_name = "alias"];
inline bool RangeTableFunc::_internal_has_alias() const {
  return this != internal_default_instance() && alias_ != nullptr;
}
inline bool RangeTableFunc::has_alias() const {
  return _internal_has_alias();
}
inline void RangeTableFunc::clear_alias() {
  if (GetArena() == nullptr && alias_ != nullptr) {
    delete alias_;
  }
  alias_ = nullptr;
}
inline const ::pg_query::Alias& RangeTableFunc::_internal_alias() const {
  const ::pg_query::Alias* p = alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(
      ::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& RangeTableFunc::alias() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.alias)
  return _internal_alias();
}
inline void RangeTableFunc::unsafe_arena_set_allocated_alias(
    ::pg_query::Alias* alias) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alias_);
  }
  alias_ = alias;
  if (alias) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFunc.alias)
}
inline ::pg_query::Alias* RangeTableFunc::release_alias() {
  
  ::pg_query::Alias* temp = alias_;
  alias_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Alias* RangeTableFunc::unsafe_arena_release_alias() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFunc.alias)
  
  ::pg_query::Alias* temp = alias_;
  alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* RangeTableFunc::_internal_mutable_alias() {
  
  if (alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    alias_ = p;
  }
  return alias_;
}
inline ::pg_query::Alias* RangeTableFunc::mutable_alias() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFunc.alias)
  return _internal_mutable_alias();
}
inline void RangeTableFunc::set_allocated_alias(::pg_query::Alias* alias) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete alias_;
  }
  if (alias) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(alias);
    if (message_arena != submessage_arena) {
      alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, alias, submessage_arena);
    }
    
  } else {
    
  }
  alias_ = alias;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFunc.alias)
}

// int32 location = 7 [json_name = "location"];
inline void RangeTableFunc::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTableFunc::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTableFunc::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.location)
  return _internal_location();
}
inline void RangeTableFunc::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void RangeTableFunc::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTableFunc.location)
}

// -------------------------------------------------------------------

// RangeTableFuncCol

// string colname = 1 [json_name = "colname"];
inline void RangeTableFuncCol::clear_colname() {
  colname_.ClearToEmpty();
}
inline const std::string& RangeTableFuncCol::colname() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.colname)
  return _internal_colname();
}
inline void RangeTableFuncCol::set_colname(const std::string& value) {
  _internal_set_colname(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTableFuncCol.colname)
}
inline std::string* RangeTableFuncCol::mutable_colname() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFuncCol.colname)
  return _internal_mutable_colname();
}
inline const std::string& RangeTableFuncCol::_internal_colname() const {
  return colname_.Get();
}
inline void RangeTableFuncCol::_internal_set_colname(const std::string& value) {
  
  colname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RangeTableFuncCol::set_colname(std::string&& value) {
  
  colname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.RangeTableFuncCol.colname)
}
inline void RangeTableFuncCol::set_colname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  colname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.RangeTableFuncCol.colname)
}
inline void RangeTableFuncCol::set_colname(const char* value,
    size_t size) {
  
  colname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.RangeTableFuncCol.colname)
}
inline std::string* RangeTableFuncCol::_internal_mutable_colname() {
  
  return colname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RangeTableFuncCol::release_colname() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFuncCol.colname)
  return colname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RangeTableFuncCol::set_allocated_colname(std::string* colname) {
  if (colname != nullptr) {
    
  } else {
    
  }
  colname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), colname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFuncCol.colname)
}

// .pg_query.TypeName type_name = 2 [json_name = "typeName"];
inline bool RangeTableFuncCol::_internal_has_type_name() const {
  return this != internal_default_instance() && type_name_ != nullptr;
}
inline bool RangeTableFuncCol::has_type_name() const {
  return _internal_has_type_name();
}
inline void RangeTableFuncCol::clear_type_name() {
  if (GetArena() == nullptr && type_name_ != nullptr) {
    delete type_name_;
  }
  type_name_ = nullptr;
}
inline const ::pg_query::TypeName& RangeTableFuncCol::_internal_type_name() const {
  const ::pg_query::TypeName* p = type_name_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(
      ::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& RangeTableFuncCol::type_name() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.type_name)
  return _internal_type_name();
}
inline void RangeTableFuncCol::unsafe_arena_set_allocated_type_name(
    ::pg_query::TypeName* type_name) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_name_);
  }
  type_name_ = type_name;
  if (type_name) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFuncCol.type_name)
}
inline ::pg_query::TypeName* RangeTableFuncCol::release_type_name() {
  
  ::pg_query::TypeName* temp = type_name_;
  type_name_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TypeName* RangeTableFuncCol::unsafe_arena_release_type_name() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFuncCol.type_name)
  
  ::pg_query::TypeName* temp = type_name_;
  type_name_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* RangeTableFuncCol::_internal_mutable_type_name() {
  
  if (type_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    type_name_ = p;
  }
  return type_name_;
}
inline ::pg_query::TypeName* RangeTableFuncCol::mutable_type_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFuncCol.type_name)
  return _internal_mutable_type_name();
}
inline void RangeTableFuncCol::set_allocated_type_name(::pg_query::TypeName* type_name) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete type_name_;
  }
  if (type_name) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_name);
    if (message_arena != submessage_arena) {
      type_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, type_name, submessage_arena);
    }
    
  } else {
    
  }
  type_name_ = type_name;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFuncCol.type_name)
}

// bool for_ordinality = 3 [json_name = "for_ordinality"];
inline void RangeTableFuncCol::clear_for_ordinality() {
  for_ordinality_ = false;
}
inline bool RangeTableFuncCol::_internal_for_ordinality() const {
  return for_ordinality_;
}
inline bool RangeTableFuncCol::for_ordinality() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.for_ordinality)
  return _internal_for_ordinality();
}
inline void RangeTableFuncCol::_internal_set_for_ordinality(bool value) {
  
  for_ordinality_ = value;
}
inline void RangeTableFuncCol::set_for_ordinality(bool value) {
  _internal_set_for_ordinality(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTableFuncCol.for_ordinality)
}

// bool is_not_null = 4 [json_name = "is_not_null"];
inline void RangeTableFuncCol::clear_is_not_null() {
  is_not_null_ = false;
}
inline bool RangeTableFuncCol::_internal_is_not_null() const {
  return is_not_null_;
}
inline bool RangeTableFuncCol::is_not_null() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.is_not_null)
  return _internal_is_not_null();
}
inline void RangeTableFuncCol::_internal_set_is_not_null(bool value) {
  
  is_not_null_ = value;
}
inline void RangeTableFuncCol::set_is_not_null(bool value) {
  _internal_set_is_not_null(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTableFuncCol.is_not_null)
}

// .pg_query.Node colexpr = 5 [json_name = "colexpr"];
inline bool RangeTableFuncCol::_internal_has_colexpr() const {
  return this != internal_default_instance() && colexpr_ != nullptr;
}
inline bool RangeTableFuncCol::has_colexpr() const {
  return _internal_has_colexpr();
}
inline void RangeTableFuncCol::clear_colexpr() {
  if (GetArena() == nullptr && colexpr_ != nullptr) {
    delete colexpr_;
  }
  colexpr_ = nullptr;
}
inline const ::pg_query::Node& RangeTableFuncCol::_internal_colexpr() const {
  const ::pg_query::Node* p = colexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTableFuncCol::colexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.colexpr)
  return _internal_colexpr();
}
inline void RangeTableFuncCol::unsafe_arena_set_allocated_colexpr(
    ::pg_query::Node* colexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(colexpr_);
  }
  colexpr_ = colexpr;
  if (colexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFuncCol.colexpr)
}
inline ::pg_query::Node* RangeTableFuncCol::release_colexpr() {
  
  ::pg_query::Node* temp = colexpr_;
  colexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RangeTableFuncCol::unsafe_arena_release_colexpr() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFuncCol.colexpr)
  
  ::pg_query::Node* temp = colexpr_;
  colexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTableFuncCol::_internal_mutable_colexpr() {
  
  if (colexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    colexpr_ = p;
  }
  return colexpr_;
}
inline ::pg_query::Node* RangeTableFuncCol::mutable_colexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFuncCol.colexpr)
  return _internal_mutable_colexpr();
}
inline void RangeTableFuncCol::set_allocated_colexpr(::pg_query::Node* colexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete colexpr_;
  }
  if (colexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(colexpr);
    if (message_arena != submessage_arena) {
      colexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, colexpr, submessage_arena);
    }
    
  } else {
    
  }
  colexpr_ = colexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFuncCol.colexpr)
}

// .pg_query.Node coldefexpr = 6 [json_name = "coldefexpr"];
inline bool RangeTableFuncCol::_internal_has_coldefexpr() const {
  return this != internal_default_instance() && coldefexpr_ != nullptr;
}
inline bool RangeTableFuncCol::has_coldefexpr() const {
  return _internal_has_coldefexpr();
}
inline void RangeTableFuncCol::clear_coldefexpr() {
  if (GetArena() == nullptr && coldefexpr_ != nullptr) {
    delete coldefexpr_;
  }
  coldefexpr_ = nullptr;
}
inline const ::pg_query::Node& RangeTableFuncCol::_internal_coldefexpr() const {
  const ::pg_query::Node* p = coldefexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTableFuncCol::coldefexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.coldefexpr)
  return _internal_coldefexpr();
}
inline void RangeTableFuncCol::unsafe_arena_set_allocated_coldefexpr(
    ::pg_query::Node* coldefexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(coldefexpr_);
  }
  coldefexpr_ = coldefexpr;
  if (coldefexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFuncCol.coldefexpr)
}
inline ::pg_query::Node* RangeTableFuncCol::release_coldefexpr() {
  
  ::pg_query::Node* temp = coldefexpr_;
  coldefexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RangeTableFuncCol::unsafe_arena_release_coldefexpr() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFuncCol.coldefexpr)
  
  ::pg_query::Node* temp = coldefexpr_;
  coldefexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTableFuncCol::_internal_mutable_coldefexpr() {
  
  if (coldefexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    coldefexpr_ = p;
  }
  return coldefexpr_;
}
inline ::pg_query::Node* RangeTableFuncCol::mutable_coldefexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFuncCol.coldefexpr)
  return _internal_mutable_coldefexpr();
}
inline void RangeTableFuncCol::set_allocated_coldefexpr(::pg_query::Node* coldefexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete coldefexpr_;
  }
  if (coldefexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(coldefexpr);
    if (message_arena != submessage_arena) {
      coldefexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, coldefexpr, submessage_arena);
    }
    
  } else {
    
  }
  coldefexpr_ = coldefexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFuncCol.coldefexpr)
}

// int32 location = 7 [json_name = "location"];
inline void RangeTableFuncCol::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTableFuncCol::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTableFuncCol::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.location)
  return _internal_location();
}
inline void RangeTableFuncCol::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void RangeTableFuncCol::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTableFuncCol.location)
}

// -------------------------------------------------------------------

// TypeName

// repeated .pg_query.Node names = 1 [json_name = "names"];
inline int TypeName::_internal_names_size() const {
  return names_.size();
}
inline int TypeName::names_size() const {
  return _internal_names_size();
}
inline void TypeName::clear_names() {
  names_.Clear();
}
inline ::pg_query::Node* TypeName::mutable_names(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TypeName.names)
  return names_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TypeName::mutable_names() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TypeName.names)
  return &names_;
}
inline const ::pg_query::Node& TypeName::_internal_names(int index) const {
  return names_.Get(index);
}
inline const ::pg_query::Node& TypeName::names(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.names)
  return _internal_names(index);
}
inline ::pg_query::Node* TypeName::_internal_add_names() {
  return names_.Add();
}
inline ::pg_query::Node* TypeName::add_names() {
  // @@protoc_insertion_point(field_add:pg_query.TypeName.names)
  return _internal_add_names();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TypeName::names() const {
  // @@protoc_insertion_point(field_list:pg_query.TypeName.names)
  return names_;
}

// uint32 type_oid = 2 [json_name = "typeOid"];
inline void TypeName::clear_type_oid() {
  type_oid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TypeName::_internal_type_oid() const {
  return type_oid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TypeName::type_oid() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.type_oid)
  return _internal_type_oid();
}
inline void TypeName::_internal_set_type_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  type_oid_ = value;
}
inline void TypeName::set_type_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_type_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.TypeName.type_oid)
}

// bool setof = 3 [json_name = "setof"];
inline void TypeName::clear_setof() {
  setof_ = false;
}
inline bool TypeName::_internal_setof() const {
  return setof_;
}
inline bool TypeName::setof() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.setof)
  return _internal_setof();
}
inline void TypeName::_internal_set_setof(bool value) {
  
  setof_ = value;
}
inline void TypeName::set_setof(bool value) {
  _internal_set_setof(value);
  // @@protoc_insertion_point(field_set:pg_query.TypeName.setof)
}

// bool pct_type = 4 [json_name = "pct_type"];
inline void TypeName::clear_pct_type() {
  pct_type_ = false;
}
inline bool TypeName::_internal_pct_type() const {
  return pct_type_;
}
inline bool TypeName::pct_type() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.pct_type)
  return _internal_pct_type();
}
inline void TypeName::_internal_set_pct_type(bool value) {
  
  pct_type_ = value;
}
inline void TypeName::set_pct_type(bool value) {
  _internal_set_pct_type(value);
  // @@protoc_insertion_point(field_set:pg_query.TypeName.pct_type)
}

// repeated .pg_query.Node typmods = 5 [json_name = "typmods"];
inline int TypeName::_internal_typmods_size() const {
  return typmods_.size();
}
inline int TypeName::typmods_size() const {
  return _internal_typmods_size();
}
inline void TypeName::clear_typmods() {
  typmods_.Clear();
}
inline ::pg_query::Node* TypeName::mutable_typmods(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TypeName.typmods)
  return typmods_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TypeName::mutable_typmods() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TypeName.typmods)
  return &typmods_;
}
inline const ::pg_query::Node& TypeName::_internal_typmods(int index) const {
  return typmods_.Get(index);
}
inline const ::pg_query::Node& TypeName::typmods(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.typmods)
  return _internal_typmods(index);
}
inline ::pg_query::Node* TypeName::_internal_add_typmods() {
  return typmods_.Add();
}
inline ::pg_query::Node* TypeName::add_typmods() {
  // @@protoc_insertion_point(field_add:pg_query.TypeName.typmods)
  return _internal_add_typmods();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TypeName::typmods() const {
  // @@protoc_insertion_point(field_list:pg_query.TypeName.typmods)
  return typmods_;
}

// int32 typemod = 6 [json_name = "typemod"];
inline void TypeName::clear_typemod() {
  typemod_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TypeName::_internal_typemod() const {
  return typemod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TypeName::typemod() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.typemod)
  return _internal_typemod();
}
inline void TypeName::_internal_set_typemod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  typemod_ = value;
}
inline void TypeName::set_typemod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_typemod(value);
  // @@protoc_insertion_point(field_set:pg_query.TypeName.typemod)
}

// repeated .pg_query.Node array_bounds = 7 [json_name = "arrayBounds"];
inline int TypeName::_internal_array_bounds_size() const {
  return array_bounds_.size();
}
inline int TypeName::array_bounds_size() const {
  return _internal_array_bounds_size();
}
inline void TypeName::clear_array_bounds() {
  array_bounds_.Clear();
}
inline ::pg_query::Node* TypeName::mutable_array_bounds(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TypeName.array_bounds)
  return array_bounds_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TypeName::mutable_array_bounds() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TypeName.array_bounds)
  return &array_bounds_;
}
inline const ::pg_query::Node& TypeName::_internal_array_bounds(int index) const {
  return array_bounds_.Get(index);
}
inline const ::pg_query::Node& TypeName::array_bounds(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.array_bounds)
  return _internal_array_bounds(index);
}
inline ::pg_query::Node* TypeName::_internal_add_array_bounds() {
  return array_bounds_.Add();
}
inline ::pg_query::Node* TypeName::add_array_bounds() {
  // @@protoc_insertion_point(field_add:pg_query.TypeName.array_bounds)
  return _internal_add_array_bounds();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TypeName::array_bounds() const {
  // @@protoc_insertion_point(field_list:pg_query.TypeName.array_bounds)
  return array_bounds_;
}

// int32 location = 8 [json_name = "location"];
inline void TypeName::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TypeName::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TypeName::location() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.location)
  return _internal_location();
}
inline void TypeName::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void TypeName::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.TypeName.location)
}

// -------------------------------------------------------------------

// ColumnDef

// string colname = 1 [json_name = "colname"];
inline void ColumnDef::clear_colname() {
  colname_.ClearToEmpty();
}
inline const std::string& ColumnDef::colname() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.colname)
  return _internal_colname();
}
inline void ColumnDef::set_colname(const std::string& value) {
  _internal_set_colname(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.colname)
}
inline std::string* ColumnDef::mutable_colname() {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.colname)
  return _internal_mutable_colname();
}
inline const std::string& ColumnDef::_internal_colname() const {
  return colname_.Get();
}
inline void ColumnDef::_internal_set_colname(const std::string& value) {
  
  colname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ColumnDef::set_colname(std::string&& value) {
  
  colname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ColumnDef.colname)
}
inline void ColumnDef::set_colname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  colname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ColumnDef.colname)
}
inline void ColumnDef::set_colname(const char* value,
    size_t size) {
  
  colname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ColumnDef.colname)
}
inline std::string* ColumnDef::_internal_mutable_colname() {
  
  return colname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ColumnDef::release_colname() {
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.colname)
  return colname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ColumnDef::set_allocated_colname(std::string* colname) {
  if (colname != nullptr) {
    
  } else {
    
  }
  colname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), colname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.colname)
}

// .pg_query.TypeName type_name = 2 [json_name = "typeName"];
inline bool ColumnDef::_internal_has_type_name() const {
  return this != internal_default_instance() && type_name_ != nullptr;
}
inline bool ColumnDef::has_type_name() const {
  return _internal_has_type_name();
}
inline void ColumnDef::clear_type_name() {
  if (GetArena() == nullptr && type_name_ != nullptr) {
    delete type_name_;
  }
  type_name_ = nullptr;
}
inline const ::pg_query::TypeName& ColumnDef::_internal_type_name() const {
  const ::pg_query::TypeName* p = type_name_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(
      ::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& ColumnDef::type_name() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.type_name)
  return _internal_type_name();
}
inline void ColumnDef::unsafe_arena_set_allocated_type_name(
    ::pg_query::TypeName* type_name) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_name_);
  }
  type_name_ = type_name;
  if (type_name) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.type_name)
}
inline ::pg_query::TypeName* ColumnDef::release_type_name() {
  
  ::pg_query::TypeName* temp = type_name_;
  type_name_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TypeName* ColumnDef::unsafe_arena_release_type_name() {
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.type_name)
  
  ::pg_query::TypeName* temp = type_name_;
  type_name_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* ColumnDef::_internal_mutable_type_name() {
  
  if (type_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    type_name_ = p;
  }
  return type_name_;
}
inline ::pg_query::TypeName* ColumnDef::mutable_type_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.type_name)
  return _internal_mutable_type_name();
}
inline void ColumnDef::set_allocated_type_name(::pg_query::TypeName* type_name) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete type_name_;
  }
  if (type_name) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_name);
    if (message_arena != submessage_arena) {
      type_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, type_name, submessage_arena);
    }
    
  } else {
    
  }
  type_name_ = type_name;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.type_name)
}

// int32 inhcount = 3 [json_name = "inhcount"];
inline void ColumnDef::clear_inhcount() {
  inhcount_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ColumnDef::_internal_inhcount() const {
  return inhcount_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ColumnDef::inhcount() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.inhcount)
  return _internal_inhcount();
}
inline void ColumnDef::_internal_set_inhcount(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  inhcount_ = value;
}
inline void ColumnDef::set_inhcount(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_inhcount(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.inhcount)
}

// bool is_local = 4 [json_name = "is_local"];
inline void ColumnDef::clear_is_local() {
  is_local_ = false;
}
inline bool ColumnDef::_internal_is_local() const {
  return is_local_;
}
inline bool ColumnDef::is_local() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.is_local)
  return _internal_is_local();
}
inline void ColumnDef::_internal_set_is_local(bool value) {
  
  is_local_ = value;
}
inline void ColumnDef::set_is_local(bool value) {
  _internal_set_is_local(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.is_local)
}

// bool is_not_null = 5 [json_name = "is_not_null"];
inline void ColumnDef::clear_is_not_null() {
  is_not_null_ = false;
}
inline bool ColumnDef::_internal_is_not_null() const {
  return is_not_null_;
}
inline bool ColumnDef::is_not_null() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.is_not_null)
  return _internal_is_not_null();
}
inline void ColumnDef::_internal_set_is_not_null(bool value) {
  
  is_not_null_ = value;
}
inline void ColumnDef::set_is_not_null(bool value) {
  _internal_set_is_not_null(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.is_not_null)
}

// bool is_from_type = 6 [json_name = "is_from_type"];
inline void ColumnDef::clear_is_from_type() {
  is_from_type_ = false;
}
inline bool ColumnDef::_internal_is_from_type() const {
  return is_from_type_;
}
inline bool ColumnDef::is_from_type() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.is_from_type)
  return _internal_is_from_type();
}
inline void ColumnDef::_internal_set_is_from_type(bool value) {
  
  is_from_type_ = value;
}
inline void ColumnDef::set_is_from_type(bool value) {
  _internal_set_is_from_type(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.is_from_type)
}

// string storage = 7 [json_name = "storage"];
inline void ColumnDef::clear_storage() {
  storage_.ClearToEmpty();
}
inline const std::string& ColumnDef::storage() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.storage)
  return _internal_storage();
}
inline void ColumnDef::set_storage(const std::string& value) {
  _internal_set_storage(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.storage)
}
inline std::string* ColumnDef::mutable_storage() {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.storage)
  return _internal_mutable_storage();
}
inline const std::string& ColumnDef::_internal_storage() const {
  return storage_.Get();
}
inline void ColumnDef::_internal_set_storage(const std::string& value) {
  
  storage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ColumnDef::set_storage(std::string&& value) {
  
  storage_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ColumnDef.storage)
}
inline void ColumnDef::set_storage(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  storage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ColumnDef.storage)
}
inline void ColumnDef::set_storage(const char* value,
    size_t size) {
  
  storage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ColumnDef.storage)
}
inline std::string* ColumnDef::_internal_mutable_storage() {
  
  return storage_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ColumnDef::release_storage() {
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.storage)
  return storage_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ColumnDef::set_allocated_storage(std::string* storage) {
  if (storage != nullptr) {
    
  } else {
    
  }
  storage_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), storage,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.storage)
}

// .pg_query.Node raw_default = 8 [json_name = "raw_default"];
inline bool ColumnDef::_internal_has_raw_default() const {
  return this != internal_default_instance() && raw_default_ != nullptr;
}
inline bool ColumnDef::has_raw_default() const {
  return _internal_has_raw_default();
}
inline void ColumnDef::clear_raw_default() {
  if (GetArena() == nullptr && raw_default_ != nullptr) {
    delete raw_default_;
  }
  raw_default_ = nullptr;
}
inline const ::pg_query::Node& ColumnDef::_internal_raw_default() const {
  const ::pg_query::Node* p = raw_default_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ColumnDef::raw_default() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.raw_default)
  return _internal_raw_default();
}
inline void ColumnDef::unsafe_arena_set_allocated_raw_default(
    ::pg_query::Node* raw_default) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(raw_default_);
  }
  raw_default_ = raw_default;
  if (raw_default) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.raw_default)
}
inline ::pg_query::Node* ColumnDef::release_raw_default() {
  
  ::pg_query::Node* temp = raw_default_;
  raw_default_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* ColumnDef::unsafe_arena_release_raw_default() {
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.raw_default)
  
  ::pg_query::Node* temp = raw_default_;
  raw_default_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ColumnDef::_internal_mutable_raw_default() {
  
  if (raw_default_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    raw_default_ = p;
  }
  return raw_default_;
}
inline ::pg_query::Node* ColumnDef::mutable_raw_default() {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.raw_default)
  return _internal_mutable_raw_default();
}
inline void ColumnDef::set_allocated_raw_default(::pg_query::Node* raw_default) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete raw_default_;
  }
  if (raw_default) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(raw_default);
    if (message_arena != submessage_arena) {
      raw_default = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, raw_default, submessage_arena);
    }
    
  } else {
    
  }
  raw_default_ = raw_default;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.raw_default)
}

// .pg_query.Node cooked_default = 9 [json_name = "cooked_default"];
inline bool ColumnDef::_internal_has_cooked_default() const {
  return this != internal_default_instance() && cooked_default_ != nullptr;
}
inline bool ColumnDef::has_cooked_default() const {
  return _internal_has_cooked_default();
}
inline void ColumnDef::clear_cooked_default() {
  if (GetArena() == nullptr && cooked_default_ != nullptr) {
    delete cooked_default_;
  }
  cooked_default_ = nullptr;
}
inline const ::pg_query::Node& ColumnDef::_internal_cooked_default() const {
  const ::pg_query::Node* p = cooked_default_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ColumnDef::cooked_default() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.cooked_default)
  return _internal_cooked_default();
}
inline void ColumnDef::unsafe_arena_set_allocated_cooked_default(
    ::pg_query::Node* cooked_default) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cooked_default_);
  }
  cooked_default_ = cooked_default;
  if (cooked_default) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.cooked_default)
}
inline ::pg_query::Node* ColumnDef::release_cooked_default() {
  
  ::pg_query::Node* temp = cooked_default_;
  cooked_default_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* ColumnDef::unsafe_arena_release_cooked_default() {
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.cooked_default)
  
  ::pg_query::Node* temp = cooked_default_;
  cooked_default_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ColumnDef::_internal_mutable_cooked_default() {
  
  if (cooked_default_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    cooked_default_ = p;
  }
  return cooked_default_;
}
inline ::pg_query::Node* ColumnDef::mutable_cooked_default() {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.cooked_default)
  return _internal_mutable_cooked_default();
}
inline void ColumnDef::set_allocated_cooked_default(::pg_query::Node* cooked_default) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete cooked_default_;
  }
  if (cooked_default) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(cooked_default);
    if (message_arena != submessage_arena) {
      cooked_default = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cooked_default, submessage_arena);
    }
    
  } else {
    
  }
  cooked_default_ = cooked_default;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.cooked_default)
}

// string identity = 10 [json_name = "identity"];
inline void ColumnDef::clear_identity() {
  identity_.ClearToEmpty();
}
inline const std::string& ColumnDef::identity() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.identity)
  return _internal_identity();
}
inline void ColumnDef::set_identity(const std::string& value) {
  _internal_set_identity(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.identity)
}
inline std::string* ColumnDef::mutable_identity() {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.identity)
  return _internal_mutable_identity();
}
inline const std::string& ColumnDef::_internal_identity() const {
  return identity_.Get();
}
inline void ColumnDef::_internal_set_identity(const std::string& value) {
  
  identity_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ColumnDef::set_identity(std::string&& value) {
  
  identity_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ColumnDef.identity)
}
inline void ColumnDef::set_identity(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  identity_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ColumnDef.identity)
}
inline void ColumnDef::set_identity(const char* value,
    size_t size) {
  
  identity_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ColumnDef.identity)
}
inline std::string* ColumnDef::_internal_mutable_identity() {
  
  return identity_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ColumnDef::release_identity() {
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.identity)
  return identity_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ColumnDef::set_allocated_identity(std::string* identity) {
  if (identity != nullptr) {
    
  } else {
    
  }
  identity_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), identity,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.identity)
}

// .pg_query.RangeVar identity_sequence = 11 [json_name = "identitySequence"];
inline bool ColumnDef::_internal_has_identity_sequence() const {
  return this != internal_default_instance() && identity_sequence_ != nullptr;
}
inline bool ColumnDef::has_identity_sequence() const {
  return _internal_has_identity_sequence();
}
inline void ColumnDef::clear_identity_sequence() {
  if (GetArena() == nullptr && identity_sequence_ != nullptr) {
    delete identity_sequence_;
  }
  identity_sequence_ = nullptr;
}
inline const ::pg_query::RangeVar& ColumnDef::_internal_identity_sequence() const {
  const ::pg_query::RangeVar* p = identity_sequence_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& ColumnDef::identity_sequence() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.identity_sequence)
  return _internal_identity_sequence();
}
inline void ColumnDef::unsafe_arena_set_allocated_identity_sequence(
    ::pg_query::RangeVar* identity_sequence) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(identity_sequence_);
  }
  identity_sequence_ = identity_sequence;
  if (identity_sequence) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.identity_sequence)
}
inline ::pg_query::RangeVar* ColumnDef::release_identity_sequence() {
  
  ::pg_query::RangeVar* temp = identity_sequence_;
  identity_sequence_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* ColumnDef::unsafe_arena_release_identity_sequence() {
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.identity_sequence)
  
  ::pg_query::RangeVar* temp = identity_sequence_;
  identity_sequence_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* ColumnDef::_internal_mutable_identity_sequence() {
  
  if (identity_sequence_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    identity_sequence_ = p;
  }
  return identity_sequence_;
}
inline ::pg_query::RangeVar* ColumnDef::mutable_identity_sequence() {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.identity_sequence)
  return _internal_mutable_identity_sequence();
}
inline void ColumnDef::set_allocated_identity_sequence(::pg_query::RangeVar* identity_sequence) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete identity_sequence_;
  }
  if (identity_sequence) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(identity_sequence);
    if (message_arena != submessage_arena) {
      identity_sequence = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, identity_sequence, submessage_arena);
    }
    
  } else {
    
  }
  identity_sequence_ = identity_sequence;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.identity_sequence)
}

// string generated = 12 [json_name = "generated"];
inline void ColumnDef::clear_generated() {
  generated_.ClearToEmpty();
}
inline const std::string& ColumnDef::generated() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.generated)
  return _internal_generated();
}
inline void ColumnDef::set_generated(const std::string& value) {
  _internal_set_generated(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.generated)
}
inline std::string* ColumnDef::mutable_generated() {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.generated)
  return _internal_mutable_generated();
}
inline const std::string& ColumnDef::_internal_generated() const {
  return generated_.Get();
}
inline void ColumnDef::_internal_set_generated(const std::string& value) {
  
  generated_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ColumnDef::set_generated(std::string&& value) {
  
  generated_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.ColumnDef.generated)
}
inline void ColumnDef::set_generated(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  generated_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.ColumnDef.generated)
}
inline void ColumnDef::set_generated(const char* value,
    size_t size) {
  
  generated_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.ColumnDef.generated)
}
inline std::string* ColumnDef::_internal_mutable_generated() {
  
  return generated_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ColumnDef::release_generated() {
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.generated)
  return generated_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ColumnDef::set_allocated_generated(std::string* generated) {
  if (generated != nullptr) {
    
  } else {
    
  }
  generated_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), generated,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.generated)
}

// .pg_query.CollateClause coll_clause = 13 [json_name = "collClause"];
inline bool ColumnDef::_internal_has_coll_clause() const {
  return this != internal_default_instance() && coll_clause_ != nullptr;
}
inline bool ColumnDef::has_coll_clause() const {
  return _internal_has_coll_clause();
}
inline void ColumnDef::clear_coll_clause() {
  if (GetArena() == nullptr && coll_clause_ != nullptr) {
    delete coll_clause_;
  }
  coll_clause_ = nullptr;
}
inline const ::pg_query::CollateClause& ColumnDef::_internal_coll_clause() const {
  const ::pg_query::CollateClause* p = coll_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::CollateClause&>(
      ::pg_query::_CollateClause_default_instance_);
}
inline const ::pg_query::CollateClause& ColumnDef::coll_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.coll_clause)
  return _internal_coll_clause();
}
inline void ColumnDef::unsafe_arena_set_allocated_coll_clause(
    ::pg_query::CollateClause* coll_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(coll_clause_);
  }
  coll_clause_ = coll_clause;
  if (coll_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.coll_clause)
}
inline ::pg_query::CollateClause* ColumnDef::release_coll_clause() {
  
  ::pg_query::CollateClause* temp = coll_clause_;
  coll_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::CollateClause* ColumnDef::unsafe_arena_release_coll_clause() {
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.coll_clause)
  
  ::pg_query::CollateClause* temp = coll_clause_;
  coll_clause_ = nullptr;
  return temp;
}
inline ::pg_query::CollateClause* ColumnDef::_internal_mutable_coll_clause() {
  
  if (coll_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::CollateClause>(GetArena());
    coll_clause_ = p;
  }
  return coll_clause_;
}
inline ::pg_query::CollateClause* ColumnDef::mutable_coll_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.coll_clause)
  return _internal_mutable_coll_clause();
}
inline void ColumnDef::set_allocated_coll_clause(::pg_query::CollateClause* coll_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete coll_clause_;
  }
  if (coll_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(coll_clause);
    if (message_arena != submessage_arena) {
      coll_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, coll_clause, submessage_arena);
    }
    
  } else {
    
  }
  coll_clause_ = coll_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.coll_clause)
}

// uint32 coll_oid = 14 [json_name = "collOid"];
inline void ColumnDef::clear_coll_oid() {
  coll_oid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ColumnDef::_internal_coll_oid() const {
  return coll_oid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ColumnDef::coll_oid() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.coll_oid)
  return _internal_coll_oid();
}
inline void ColumnDef::_internal_set_coll_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  coll_oid_ = value;
}
inline void ColumnDef::set_coll_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_coll_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.coll_oid)
}

// repeated .pg_query.Node constraints = 15 [json_name = "constraints"];
inline int ColumnDef::_internal_constraints_size() const {
  return constraints_.size();
}
inline int ColumnDef::constraints_size() const {
  return _internal_constraints_size();
}
inline void ColumnDef::clear_constraints() {
  constraints_.Clear();
}
inline ::pg_query::Node* ColumnDef::mutable_constraints(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.constraints)
  return constraints_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ColumnDef::mutable_constraints() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ColumnDef.constraints)
  return &constraints_;
}
inline const ::pg_query::Node& ColumnDef::_internal_constraints(int index) const {
  return constraints_.Get(index);
}
inline const ::pg_query::Node& ColumnDef::constraints(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.constraints)
  return _internal_constraints(index);
}
inline ::pg_query::Node* ColumnDef::_internal_add_constraints() {
  return constraints_.Add();
}
inline ::pg_query::Node* ColumnDef::add_constraints() {
  // @@protoc_insertion_point(field_add:pg_query.ColumnDef.constraints)
  return _internal_add_constraints();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ColumnDef::constraints() const {
  // @@protoc_insertion_point(field_list:pg_query.ColumnDef.constraints)
  return constraints_;
}

// repeated .pg_query.Node fdwoptions = 16 [json_name = "fdwoptions"];
inline int ColumnDef::_internal_fdwoptions_size() const {
  return fdwoptions_.size();
}
inline int ColumnDef::fdwoptions_size() const {
  return _internal_fdwoptions_size();
}
inline void ColumnDef::clear_fdwoptions() {
  fdwoptions_.Clear();
}
inline ::pg_query::Node* ColumnDef::mutable_fdwoptions(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.fdwoptions)
  return fdwoptions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ColumnDef::mutable_fdwoptions() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ColumnDef.fdwoptions)
  return &fdwoptions_;
}
inline const ::pg_query::Node& ColumnDef::_internal_fdwoptions(int index) const {
  return fdwoptions_.Get(index);
}
inline const ::pg_query::Node& ColumnDef::fdwoptions(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.fdwoptions)
  return _internal_fdwoptions(index);
}
inline ::pg_query::Node* ColumnDef::_internal_add_fdwoptions() {
  return fdwoptions_.Add();
}
inline ::pg_query::Node* ColumnDef::add_fdwoptions() {
  // @@protoc_insertion_point(field_add:pg_query.ColumnDef.fdwoptions)
  return _internal_add_fdwoptions();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ColumnDef::fdwoptions() const {
  // @@protoc_insertion_point(field_list:pg_query.ColumnDef.fdwoptions)
  return fdwoptions_;
}

// int32 location = 17 [json_name = "location"];
inline void ColumnDef::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ColumnDef::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ColumnDef::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.location)
  return _internal_location();
}
inline void ColumnDef::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void ColumnDef::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.location)
}

// -------------------------------------------------------------------

// IndexElem

// string name = 1 [json_name = "name"];
inline void IndexElem::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& IndexElem::name() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.name)
  return _internal_name();
}
inline void IndexElem::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexElem.name)
}
inline std::string* IndexElem::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.name)
  return _internal_mutable_name();
}
inline const std::string& IndexElem::_internal_name() const {
  return name_.Get();
}
inline void IndexElem::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void IndexElem::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.IndexElem.name)
}
inline void IndexElem::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.IndexElem.name)
}
inline void IndexElem::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.IndexElem.name)
}
inline std::string* IndexElem::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* IndexElem::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.IndexElem.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void IndexElem::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexElem.name)
}

// .pg_query.Node expr = 2 [json_name = "expr"];
inline bool IndexElem::_internal_has_expr() const {
  return this != internal_default_instance() && expr_ != nullptr;
}
inline bool IndexElem::has_expr() const {
  return _internal_has_expr();
}
inline void IndexElem::clear_expr() {
  if (GetArena() == nullptr && expr_ != nullptr) {
    delete expr_;
  }
  expr_ = nullptr;
}
inline const ::pg_query::Node& IndexElem::_internal_expr() const {
  const ::pg_query::Node* p = expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& IndexElem::expr() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.expr)
  return _internal_expr();
}
inline void IndexElem::unsafe_arena_set_allocated_expr(
    ::pg_query::Node* expr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expr_);
  }
  expr_ = expr;
  if (expr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IndexElem.expr)
}
inline ::pg_query::Node* IndexElem::release_expr() {
  
  ::pg_query::Node* temp = expr_;
  expr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* IndexElem::unsafe_arena_release_expr() {
  // @@protoc_insertion_point(field_release:pg_query.IndexElem.expr)
  
  ::pg_query::Node* temp = expr_;
  expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* IndexElem::_internal_mutable_expr() {
  
  if (expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    expr_ = p;
  }
  return expr_;
}
inline ::pg_query::Node* IndexElem::mutable_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.expr)
  return _internal_mutable_expr();
}
inline void IndexElem::set_allocated_expr(::pg_query::Node* expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete expr_;
  }
  if (expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expr);
    if (message_arena != submessage_arena) {
      expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, expr, submessage_arena);
    }
    
  } else {
    
  }
  expr_ = expr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexElem.expr)
}

// string indexcolname = 3 [json_name = "indexcolname"];
inline void IndexElem::clear_indexcolname() {
  indexcolname_.ClearToEmpty();
}
inline const std::string& IndexElem::indexcolname() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.indexcolname)
  return _internal_indexcolname();
}
inline void IndexElem::set_indexcolname(const std::string& value) {
  _internal_set_indexcolname(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexElem.indexcolname)
}
inline std::string* IndexElem::mutable_indexcolname() {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.indexcolname)
  return _internal_mutable_indexcolname();
}
inline const std::string& IndexElem::_internal_indexcolname() const {
  return indexcolname_.Get();
}
inline void IndexElem::_internal_set_indexcolname(const std::string& value) {
  
  indexcolname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void IndexElem::set_indexcolname(std::string&& value) {
  
  indexcolname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.IndexElem.indexcolname)
}
inline void IndexElem::set_indexcolname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  indexcolname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.IndexElem.indexcolname)
}
inline void IndexElem::set_indexcolname(const char* value,
    size_t size) {
  
  indexcolname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.IndexElem.indexcolname)
}
inline std::string* IndexElem::_internal_mutable_indexcolname() {
  
  return indexcolname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* IndexElem::release_indexcolname() {
  // @@protoc_insertion_point(field_release:pg_query.IndexElem.indexcolname)
  return indexcolname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void IndexElem::set_allocated_indexcolname(std::string* indexcolname) {
  if (indexcolname != nullptr) {
    
  } else {
    
  }
  indexcolname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), indexcolname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexElem.indexcolname)
}

// repeated .pg_query.Node collation = 4 [json_name = "collation"];
inline int IndexElem::_internal_collation_size() const {
  return collation_.size();
}
inline int IndexElem::collation_size() const {
  return _internal_collation_size();
}
inline void IndexElem::clear_collation() {
  collation_.Clear();
}
inline ::pg_query::Node* IndexElem::mutable_collation(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.collation)
  return collation_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
IndexElem::mutable_collation() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexElem.collation)
  return &collation_;
}
inline const ::pg_query::Node& IndexElem::_internal_collation(int index) const {
  return collation_.Get(index);
}
inline const ::pg_query::Node& IndexElem::collation(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.collation)
  return _internal_collation(index);
}
inline ::pg_query::Node* IndexElem::_internal_add_collation() {
  return collation_.Add();
}
inline ::pg_query::Node* IndexElem::add_collation() {
  // @@protoc_insertion_point(field_add:pg_query.IndexElem.collation)
  return _internal_add_collation();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
IndexElem::collation() const {
  // @@protoc_insertion_point(field_list:pg_query.IndexElem.collation)
  return collation_;
}

// repeated .pg_query.Node opclass = 5 [json_name = "opclass"];
inline int IndexElem::_internal_opclass_size() const {
  return opclass_.size();
}
inline int IndexElem::opclass_size() const {
  return _internal_opclass_size();
}
inline void IndexElem::clear_opclass() {
  opclass_.Clear();
}
inline ::pg_query::Node* IndexElem::mutable_opclass(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.opclass)
  return opclass_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
IndexElem::mutable_opclass() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexElem.opclass)
  return &opclass_;
}
inline const ::pg_query::Node& IndexElem::_internal_opclass(int index) const {
  return opclass_.Get(index);
}
inline const ::pg_query::Node& IndexElem::opclass(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.opclass)
  return _internal_opclass(index);
}
inline ::pg_query::Node* IndexElem::_internal_add_opclass() {
  return opclass_.Add();
}
inline ::pg_query::Node* IndexElem::add_opclass() {
  // @@protoc_insertion_point(field_add:pg_query.IndexElem.opclass)
  return _internal_add_opclass();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
IndexElem::opclass() const {
  // @@protoc_insertion_point(field_list:pg_query.IndexElem.opclass)
  return opclass_;
}

// repeated .pg_query.Node opclassopts = 6 [json_name = "opclassopts"];
inline int IndexElem::_internal_opclassopts_size() const {
  return opclassopts_.size();
}
inline int IndexElem::opclassopts_size() const {
  return _internal_opclassopts_size();
}
inline void IndexElem::clear_opclassopts() {
  opclassopts_.Clear();
}
inline ::pg_query::Node* IndexElem::mutable_opclassopts(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.opclassopts)
  return opclassopts_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
IndexElem::mutable_opclassopts() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexElem.opclassopts)
  return &opclassopts_;
}
inline const ::pg_query::Node& IndexElem::_internal_opclassopts(int index) const {
  return opclassopts_.Get(index);
}
inline const ::pg_query::Node& IndexElem::opclassopts(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.opclassopts)
  return _internal_opclassopts(index);
}
inline ::pg_query::Node* IndexElem::_internal_add_opclassopts() {
  return opclassopts_.Add();
}
inline ::pg_query::Node* IndexElem::add_opclassopts() {
  // @@protoc_insertion_point(field_add:pg_query.IndexElem.opclassopts)
  return _internal_add_opclassopts();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
IndexElem::opclassopts() const {
  // @@protoc_insertion_point(field_list:pg_query.IndexElem.opclassopts)
  return opclassopts_;
}

// .pg_query.SortByDir ordering = 7 [json_name = "ordering"];
inline void IndexElem::clear_ordering() {
  ordering_ = 0;
}
inline ::pg_query::SortByDir IndexElem::_internal_ordering() const {
  return static_cast< ::pg_query::SortByDir >(ordering_);
}
inline ::pg_query::SortByDir IndexElem::ordering() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.ordering)
  return _internal_ordering();
}
inline void IndexElem::_internal_set_ordering(::pg_query::SortByDir value) {
  
  ordering_ = value;
}
inline void IndexElem::set_ordering(::pg_query::SortByDir value) {
  _internal_set_ordering(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexElem.ordering)
}

// .pg_query.SortByNulls nulls_ordering = 8 [json_name = "nulls_ordering"];
inline void IndexElem::clear_nulls_ordering() {
  nulls_ordering_ = 0;
}
inline ::pg_query::SortByNulls IndexElem::_internal_nulls_ordering() const {
  return static_cast< ::pg_query::SortByNulls >(nulls_ordering_);
}
inline ::pg_query::SortByNulls IndexElem::nulls_ordering() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.nulls_ordering)
  return _internal_nulls_ordering();
}
inline void IndexElem::_internal_set_nulls_ordering(::pg_query::SortByNulls value) {
  
  nulls_ordering_ = value;
}
inline void IndexElem::set_nulls_ordering(::pg_query::SortByNulls value) {
  _internal_set_nulls_ordering(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexElem.nulls_ordering)
}

// -------------------------------------------------------------------

// Constraint

// .pg_query.ConstrType contype = 1 [json_name = "contype"];
inline void Constraint::clear_contype() {
  contype_ = 0;
}
inline ::pg_query::ConstrType Constraint::_internal_contype() const {
  return static_cast< ::pg_query::ConstrType >(contype_);
}
inline ::pg_query::ConstrType Constraint::contype() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.contype)
  return _internal_contype();
}
inline void Constraint::_internal_set_contype(::pg_query::ConstrType value) {
  
  contype_ = value;
}
inline void Constraint::set_contype(::pg_query::ConstrType value) {
  _internal_set_contype(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.contype)
}

// string conname = 2 [json_name = "conname"];
inline void Constraint::clear_conname() {
  conname_.ClearToEmpty();
}
inline const std::string& Constraint::conname() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.conname)
  return _internal_conname();
}
inline void Constraint::set_conname(const std::string& value) {
  _internal_set_conname(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.conname)
}
inline std::string* Constraint::mutable_conname() {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.conname)
  return _internal_mutable_conname();
}
inline const std::string& Constraint::_internal_conname() const {
  return conname_.Get();
}
inline void Constraint::_internal_set_conname(const std::string& value) {
  
  conname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Constraint::set_conname(std::string&& value) {
  
  conname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.Constraint.conname)
}
inline void Constraint::set_conname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  conname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.Constraint.conname)
}
inline void Constraint::set_conname(const char* value,
    size_t size) {
  
  conname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.Constraint.conname)
}
inline std::string* Constraint::_internal_mutable_conname() {
  
  return conname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Constraint::release_conname() {
  // @@protoc_insertion_point(field_release:pg_query.Constraint.conname)
  return conname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Constraint::set_allocated_conname(std::string* conname) {
  if (conname != nullptr) {
    
  } else {
    
  }
  conname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), conname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.conname)
}

// bool deferrable = 3 [json_name = "deferrable"];
inline void Constraint::clear_deferrable() {
  deferrable_ = false;
}
inline bool Constraint::_internal_deferrable() const {
  return deferrable_;
}
inline bool Constraint::deferrable() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.deferrable)
  return _internal_deferrable();
}
inline void Constraint::_internal_set_deferrable(bool value) {
  
  deferrable_ = value;
}
inline void Constraint::set_deferrable(bool value) {
  _internal_set_deferrable(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.deferrable)
}

// bool initdeferred = 4 [json_name = "initdeferred"];
inline void Constraint::clear_initdeferred() {
  initdeferred_ = false;
}
inline bool Constraint::_internal_initdeferred() const {
  return initdeferred_;
}
inline bool Constraint::initdeferred() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.initdeferred)
  return _internal_initdeferred();
}
inline void Constraint::_internal_set_initdeferred(bool value) {
  
  initdeferred_ = value;
}
inline void Constraint::set_initdeferred(bool value) {
  _internal_set_initdeferred(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.initdeferred)
}

// int32 location = 5 [json_name = "location"];
inline void Constraint::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Constraint::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Constraint::location() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.location)
  return _internal_location();
}
inline void Constraint::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void Constraint::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.location)
}

// bool is_no_inherit = 6 [json_name = "is_no_inherit"];
inline void Constraint::clear_is_no_inherit() {
  is_no_inherit_ = false;
}
inline bool Constraint::_internal_is_no_inherit() const {
  return is_no_inherit_;
}
inline bool Constraint::is_no_inherit() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.is_no_inherit)
  return _internal_is_no_inherit();
}
inline void Constraint::_internal_set_is_no_inherit(bool value) {
  
  is_no_inherit_ = value;
}
inline void Constraint::set_is_no_inherit(bool value) {
  _internal_set_is_no_inherit(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.is_no_inherit)
}

// .pg_query.Node raw_expr = 7 [json_name = "raw_expr"];
inline bool Constraint::_internal_has_raw_expr() const {
  return this != internal_default_instance() && raw_expr_ != nullptr;
}
inline bool Constraint::has_raw_expr() const {
  return _internal_has_raw_expr();
}
inline void Constraint::clear_raw_expr() {
  if (GetArena() == nullptr && raw_expr_ != nullptr) {
    delete raw_expr_;
  }
  raw_expr_ = nullptr;
}
inline const ::pg_query::Node& Constraint::_internal_raw_expr() const {
  const ::pg_query::Node* p = raw_expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Constraint::raw_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.raw_expr)
  return _internal_raw_expr();
}
inline void Constraint::unsafe_arena_set_allocated_raw_expr(
    ::pg_query::Node* raw_expr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(raw_expr_);
  }
  raw_expr_ = raw_expr;
  if (raw_expr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Constraint.raw_expr)
}
inline ::pg_query::Node* Constraint::release_raw_expr() {
  
  ::pg_query::Node* temp = raw_expr_;
  raw_expr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* Constraint::unsafe_arena_release_raw_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Constraint.raw_expr)
  
  ::pg_query::Node* temp = raw_expr_;
  raw_expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Constraint::_internal_mutable_raw_expr() {
  
  if (raw_expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    raw_expr_ = p;
  }
  return raw_expr_;
}
inline ::pg_query::Node* Constraint::mutable_raw_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.raw_expr)
  return _internal_mutable_raw_expr();
}
inline void Constraint::set_allocated_raw_expr(::pg_query::Node* raw_expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete raw_expr_;
  }
  if (raw_expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(raw_expr);
    if (message_arena != submessage_arena) {
      raw_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, raw_expr, submessage_arena);
    }
    
  } else {
    
  }
  raw_expr_ = raw_expr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.raw_expr)
}

// string cooked_expr = 8 [json_name = "cooked_expr"];
inline void Constraint::clear_cooked_expr() {
  cooked_expr_.ClearToEmpty();
}
inline const std::string& Constraint::cooked_expr() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.cooked_expr)
  return _internal_cooked_expr();
}
inline void Constraint::set_cooked_expr(const std::string& value) {
  _internal_set_cooked_expr(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.cooked_expr)
}
inline std::string* Constraint::mutable_cooked_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.cooked_expr)
  return _internal_mutable_cooked_expr();
}
inline const std::string& Constraint::_internal_cooked_expr() const {
  return cooked_expr_.Get();
}
inline void Constraint::_internal_set_cooked_expr(const std::string& value) {
  
  cooked_expr_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Constraint::set_cooked_expr(std::string&& value) {
  
  cooked_expr_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.Constraint.cooked_expr)
}
inline void Constraint::set_cooked_expr(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  cooked_expr_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.Constraint.cooked_expr)
}
inline void Constraint::set_cooked_expr(const char* value,
    size_t size) {
  
  cooked_expr_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.Constraint.cooked_expr)
}
inline std::string* Constraint::_internal_mutable_cooked_expr() {
  
  return cooked_expr_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Constraint::release_cooked_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Constraint.cooked_expr)
  return cooked_expr_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Constraint::set_allocated_cooked_expr(std::string* cooked_expr) {
  if (cooked_expr != nullptr) {
    
  } else {
    
  }
  cooked_expr_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cooked_expr,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.cooked_expr)
}

// string generated_when = 9 [json_name = "generated_when"];
inline void Constraint::clear_generated_when() {
  generated_when_.ClearToEmpty();
}
inline const std::string& Constraint::generated_when() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.generated_when)
  return _internal_generated_when();
}
inline void Constraint::set_generated_when(const std::string& value) {
  _internal_set_generated_when(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.generated_when)
}
inline std::string* Constraint::mutable_generated_when() {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.generated_when)
  return _internal_mutable_generated_when();
}
inline const std::string& Constraint::_internal_generated_when() const {
  return generated_when_.Get();
}
inline void Constraint::_internal_set_generated_when(const std::string& value) {
  
  generated_when_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Constraint::set_generated_when(std::string&& value) {
  
  generated_when_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.Constraint.generated_when)
}
inline void Constraint::set_generated_when(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  generated_when_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.Constraint.generated_when)
}
inline void Constraint::set_generated_when(const char* value,
    size_t size) {
  
  generated_when_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.Constraint.generated_when)
}
inline std::string* Constraint::_internal_mutable_generated_when() {
  
  return generated_when_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Constraint::release_generated_when() {
  // @@protoc_insertion_point(field_release:pg_query.Constraint.generated_when)
  return generated_when_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Constraint::set_allocated_generated_when(std::string* generated_when) {
  if (generated_when != nullptr) {
    
  } else {
    
  }
  generated_when_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), generated_when,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.generated_when)
}

// repeated .pg_query.Node keys = 10 [json_name = "keys"];
inline int Constraint::_internal_keys_size() const {
  return keys_.size();
}
inline int Constraint::keys_size() const {
  return _internal_keys_size();
}
inline void Constraint::clear_keys() {
  keys_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_keys(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.keys)
  return keys_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Constraint::mutable_keys() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.keys)
  return &keys_;
}
inline const ::pg_query::Node& Constraint::_internal_keys(int index) const {
  return keys_.Get(index);
}
inline const ::pg_query::Node& Constraint::keys(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.keys)
  return _internal_keys(index);
}
inline ::pg_query::Node* Constraint::_internal_add_keys() {
  return keys_.Add();
}
inline ::pg_query::Node* Constraint::add_keys() {
  // @@protoc_insertion_point(field_add:pg_query.Constraint.keys)
  return _internal_add_keys();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Constraint::keys() const {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.keys)
  return keys_;
}

// repeated .pg_query.Node including = 11 [json_name = "including"];
inline int Constraint::_internal_including_size() const {
  return including_.size();
}
inline int Constraint::including_size() const {
  return _internal_including_size();
}
inline void Constraint::clear_including() {
  including_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_including(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.including)
  return including_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Constraint::mutable_including() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.including)
  return &including_;
}
inline const ::pg_query::Node& Constraint::_internal_including(int index) const {
  return including_.Get(index);
}
inline const ::pg_query::Node& Constraint::including(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.including)
  return _internal_including(index);
}
inline ::pg_query::Node* Constraint::_internal_add_including() {
  return including_.Add();
}
inline ::pg_query::Node* Constraint::add_including() {
  // @@protoc_insertion_point(field_add:pg_query.Constraint.including)
  return _internal_add_including();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Constraint::including() const {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.including)
  return including_;
}

// repeated .pg_query.Node exclusions = 12 [json_name = "exclusions"];
inline int Constraint::_internal_exclusions_size() const {
  return exclusions_.size();
}
inline int Constraint::exclusions_size() const {
  return _internal_exclusions_size();
}
inline void Constraint::clear_exclusions() {
  exclusions_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_exclusions(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.exclusions)
  return exclusions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Constraint::mutable_exclusions() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.exclusions)
  return &exclusions_;
}
inline const ::pg_query::Node& Constraint::_internal_exclusions(int index) const {
  return exclusions_.Get(index);
}
inline const ::pg_query::Node& Constraint::exclusions(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.exclusions)
  return _internal_exclusions(index);
}
inline ::pg_query::Node* Constraint::_internal_add_exclusions() {
  return exclusions_.Add();
}
inline ::pg_query::Node* Constraint::add_exclusions() {
  // @@protoc_insertion_point(field_add:pg_query.Constraint.exclusions)
  return _internal_add_exclusions();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Constraint::exclusions() const {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.exclusions)
  return exclusions_;
}

// repeated .pg_query.Node options = 13 [json_name = "options"];
inline int Constraint::_internal_options_size() const {
  return options_.size();
}
inline int Constraint::options_size() const {
  return _internal_options_size();
}
inline void Constraint::clear_options() {
  options_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Constraint::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.options)
  return &options_;
}
inline const ::pg_query::Node& Constraint::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::pg_query::Node& Constraint::options(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.options)
  return _internal_options(index);
}
inline ::pg_query::Node* Constraint::_internal_add_options() {
  return options_.Add();
}
inline ::pg_query::Node* Constraint::add_options() {
  // @@protoc_insertion_point(field_add:pg_query.Constraint.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Constraint::options() const {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.options)
  return options_;
}

// string indexname = 14 [json_name = "indexname"];
inline void Constraint::clear_indexname() {
  indexname_.ClearToEmpty();
}
inline const std::string& Constraint::indexname() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.indexname)
  return _internal_indexname();
}
inline void Constraint::set_indexname(const std::string& value) {
  _internal_set_indexname(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.indexname)
}
inline std::string* Constraint::mutable_indexname() {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.indexname)
  return _internal_mutable_indexname();
}
inline const std::string& Constraint::_internal_indexname() const {
  return indexname_.Get();
}
inline void Constraint::_internal_set_indexname(const std::string& value) {
  
  indexname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Constraint::set_indexname(std::string&& value) {
  
  indexname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.Constraint.indexname)
}
inline void Constraint::set_indexname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  indexname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.Constraint.indexname)
}
inline void Constraint::set_indexname(const char* value,
    size_t size) {
  
  indexname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.Constraint.indexname)
}
inline std::string* Constraint::_internal_mutable_indexname() {
  
  return indexname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Constraint::release_indexname() {
  // @@protoc_insertion_point(field_release:pg_query.Constraint.indexname)
  return indexname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Constraint::set_allocated_indexname(std::string* indexname) {
  if (indexname != nullptr) {
    
  } else {
    
  }
  indexname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), indexname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.indexname)
}

// string indexspace = 15 [json_name = "indexspace"];
inline void Constraint::clear_indexspace() {
  indexspace_.ClearToEmpty();
}
inline const std::string& Constraint::indexspace() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.indexspace)
  return _internal_indexspace();
}
inline void Constraint::set_indexspace(const std::string& value) {
  _internal_set_indexspace(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.indexspace)
}
inline std::string* Constraint::mutable_indexspace() {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.indexspace)
  return _internal_mutable_indexspace();
}
inline const std::string& Constraint::_internal_indexspace() const {
  return indexspace_.Get();
}
inline void Constraint::_internal_set_indexspace(const std::string& value) {
  
  indexspace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Constraint::set_indexspace(std::string&& value) {
  
  indexspace_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.Constraint.indexspace)
}
inline void Constraint::set_indexspace(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  indexspace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.Constraint.indexspace)
}
inline void Constraint::set_indexspace(const char* value,
    size_t size) {
  
  indexspace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.Constraint.indexspace)
}
inline std::string* Constraint::_internal_mutable_indexspace() {
  
  return indexspace_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Constraint::release_indexspace() {
  // @@protoc_insertion_point(field_release:pg_query.Constraint.indexspace)
  return indexspace_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Constraint::set_allocated_indexspace(std::string* indexspace) {
  if (indexspace != nullptr) {
    
  } else {
    
  }
  indexspace_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), indexspace,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.indexspace)
}

// bool reset_default_tblspc = 16 [json_name = "reset_default_tblspc"];
inline void Constraint::clear_reset_default_tblspc() {
  reset_default_tblspc_ = false;
}
inline bool Constraint::_internal_reset_default_tblspc() const {
  return reset_default_tblspc_;
}
inline bool Constraint::reset_default_tblspc() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.reset_default_tblspc)
  return _internal_reset_default_tblspc();
}
inline void Constraint::_internal_set_reset_default_tblspc(bool value) {
  
  reset_default_tblspc_ = value;
}
inline void Constraint::set_reset_default_tblspc(bool value) {
  _internal_set_reset_default_tblspc(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.reset_default_tblspc)
}

// string access_method = 17 [json_name = "access_method"];
inline void Constraint::clear_access_method() {
  access_method_.ClearToEmpty();
}
inline const std::string& Constraint::access_method() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.access_method)
  return _internal_access_method();
}
inline void Constraint::set_access_method(const std::string& value) {
  _internal_set_access_method(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.access_method)
}
inline std::string* Constraint::mutable_access_method() {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.access_method)
  return _internal_mutable_access_method();
}
inline const std::string& Constraint::_internal_access_method() const {
  return access_method_.Get();
}
inline void Constraint::_internal_set_access_method(const std::string& value) {
  
  access_method_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Constraint::set_access_method(std::string&& value) {
  
  access_method_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.Constraint.access_method)
}
inline void Constraint::set_access_method(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  access_method_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.Constraint.access_method)
}
inline void Constraint::set_access_method(const char* value,
    size_t size) {
  
  access_method_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.Constraint.access_method)
}
inline std::string* Constraint::_internal_mutable_access_method() {
  
  return access_method_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Constraint::release_access_method() {
  // @@protoc_insertion_point(field_release:pg_query.Constraint.access_method)
  return access_method_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Constraint::set_allocated_access_method(std::string* access_method) {
  if (access_method != nullptr) {
    
  } else {
    
  }
  access_method_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), access_method,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.access_method)
}

// .pg_query.Node where_clause = 18 [json_name = "where_clause"];
inline bool Constraint::_internal_has_where_clause() const {
  return this != internal_default_instance() && where_clause_ != nullptr;
}
inline bool Constraint::has_where_clause() const {
  return _internal_has_where_clause();
}
inline void Constraint::clear_where_clause() {
  if (GetArena() == nullptr && where_clause_ != nullptr) {
    delete where_clause_;
  }
  where_clause_ = nullptr;
}
inline const ::pg_query::Node& Constraint::_internal_where_clause() const {
  const ::pg_query::Node* p = where_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Constraint::where_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.where_clause)
  return _internal_where_clause();
}
inline void Constraint::unsafe_arena_set_allocated_where_clause(
    ::pg_query::Node* where_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(where_clause_);
  }
  where_clause_ = where_clause;
  if (where_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Constraint.where_clause)
}
inline ::pg_query::Node* Constraint::release_where_clause() {
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* Constraint::unsafe_arena_release_where_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Constraint.where_clause)
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Constraint::_internal_mutable_where_clause() {
  
  if (where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    where_clause_ = p;
  }
  return where_clause_;
}
inline ::pg_query::Node* Constraint::mutable_where_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.where_clause)
  return _internal_mutable_where_clause();
}
inline void Constraint::set_allocated_where_clause(::pg_query::Node* where_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete where_clause_;
  }
  if (where_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(where_clause);
    if (message_arena != submessage_arena) {
      where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, where_clause, submessage_arena);
    }
    
  } else {
    
  }
  where_clause_ = where_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.where_clause)
}

// .pg_query.RangeVar pktable = 19 [json_name = "pktable"];
inline bool Constraint::_internal_has_pktable() const {
  return this != internal_default_instance() && pktable_ != nullptr;
}
inline bool Constraint::has_pktable() const {
  return _internal_has_pktable();
}
inline void Constraint::clear_pktable() {
  if (GetArena() == nullptr && pktable_ != nullptr) {
    delete pktable_;
  }
  pktable_ = nullptr;
}
inline const ::pg_query::RangeVar& Constraint::_internal_pktable() const {
  const ::pg_query::RangeVar* p = pktable_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& Constraint::pktable() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.pktable)
  return _internal_pktable();
}
inline void Constraint::unsafe_arena_set_allocated_pktable(
    ::pg_query::RangeVar* pktable) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pktable_);
  }
  pktable_ = pktable;
  if (pktable) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Constraint.pktable)
}
inline ::pg_query::RangeVar* Constraint::release_pktable() {
  
  ::pg_query::RangeVar* temp = pktable_;
  pktable_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* Constraint::unsafe_arena_release_pktable() {
  // @@protoc_insertion_point(field_release:pg_query.Constraint.pktable)
  
  ::pg_query::RangeVar* temp = pktable_;
  pktable_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* Constraint::_internal_mutable_pktable() {
  
  if (pktable_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    pktable_ = p;
  }
  return pktable_;
}
inline ::pg_query::RangeVar* Constraint::mutable_pktable() {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.pktable)
  return _internal_mutable_pktable();
}
inline void Constraint::set_allocated_pktable(::pg_query::RangeVar* pktable) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete pktable_;
  }
  if (pktable) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pktable);
    if (message_arena != submessage_arena) {
      pktable = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pktable, submessage_arena);
    }
    
  } else {
    
  }
  pktable_ = pktable;
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.pktable)
}

// repeated .pg_query.Node fk_attrs = 20 [json_name = "fk_attrs"];
inline int Constraint::_internal_fk_attrs_size() const {
  return fk_attrs_.size();
}
inline int Constraint::fk_attrs_size() const {
  return _internal_fk_attrs_size();
}
inline void Constraint::clear_fk_attrs() {
  fk_attrs_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_fk_attrs(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.fk_attrs)
  return fk_attrs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Constraint::mutable_fk_attrs() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.fk_attrs)
  return &fk_attrs_;
}
inline const ::pg_query::Node& Constraint::_internal_fk_attrs(int index) const {
  return fk_attrs_.Get(index);
}
inline const ::pg_query::Node& Constraint::fk_attrs(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_attrs)
  return _internal_fk_attrs(index);
}
inline ::pg_query::Node* Constraint::_internal_add_fk_attrs() {
  return fk_attrs_.Add();
}
inline ::pg_query::Node* Constraint::add_fk_attrs() {
  // @@protoc_insertion_point(field_add:pg_query.Constraint.fk_attrs)
  return _internal_add_fk_attrs();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Constraint::fk_attrs() const {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.fk_attrs)
  return fk_attrs_;
}

// repeated .pg_query.Node pk_attrs = 21 [json_name = "pk_attrs"];
inline int Constraint::_internal_pk_attrs_size() const {
  return pk_attrs_.size();
}
inline int Constraint::pk_attrs_size() const {
  return _internal_pk_attrs_size();
}
inline void Constraint::clear_pk_attrs() {
  pk_attrs_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_pk_attrs(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.pk_attrs)
  return pk_attrs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Constraint::mutable_pk_attrs() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.pk_attrs)
  return &pk_attrs_;
}
inline const ::pg_query::Node& Constraint::_internal_pk_attrs(int index) const {
  return pk_attrs_.Get(index);
}
inline const ::pg_query::Node& Constraint::pk_attrs(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.pk_attrs)
  return _internal_pk_attrs(index);
}
inline ::pg_query::Node* Constraint::_internal_add_pk_attrs() {
  return pk_attrs_.Add();
}
inline ::pg_query::Node* Constraint::add_pk_attrs() {
  // @@protoc_insertion_point(field_add:pg_query.Constraint.pk_attrs)
  return _internal_add_pk_attrs();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Constraint::pk_attrs() const {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.pk_attrs)
  return pk_attrs_;
}

// string fk_matchtype = 22 [json_name = "fk_matchtype"];
inline void Constraint::clear_fk_matchtype() {
  fk_matchtype_.ClearToEmpty();
}
inline const std::string& Constraint::fk_matchtype() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_matchtype)
  return _internal_fk_matchtype();
}
inline void Constraint::set_fk_matchtype(const std::string& value) {
  _internal_set_fk_matchtype(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.fk_matchtype)
}
inline std::string* Constraint::mutable_fk_matchtype() {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.fk_matchtype)
  return _internal_mutable_fk_matchtype();
}
inline const std::string& Constraint::_internal_fk_matchtype() const {
  return fk_matchtype_.Get();
}
inline void Constraint::_internal_set_fk_matchtype(const std::string& value) {
  
  fk_matchtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Constraint::set_fk_matchtype(std::string&& value) {
  
  fk_matchtype_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.Constraint.fk_matchtype)
}
inline void Constraint::set_fk_matchtype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  fk_matchtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.Constraint.fk_matchtype)
}
inline void Constraint::set_fk_matchtype(const char* value,
    size_t size) {
  
  fk_matchtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.Constraint.fk_matchtype)
}
inline std::string* Constraint::_internal_mutable_fk_matchtype() {
  
  return fk_matchtype_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Constraint::release_fk_matchtype() {
  // @@protoc_insertion_point(field_release:pg_query.Constraint.fk_matchtype)
  return fk_matchtype_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Constraint::set_allocated_fk_matchtype(std::string* fk_matchtype) {
  if (fk_matchtype != nullptr) {
    
  } else {
    
  }
  fk_matchtype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fk_matchtype,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.fk_matchtype)
}

// string fk_upd_action = 23 [json_name = "fk_upd_action"];
inline void Constraint::clear_fk_upd_action() {
  fk_upd_action_.ClearToEmpty();
}
inline const std::string& Constraint::fk_upd_action() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_upd_action)
  return _internal_fk_upd_action();
}
inline void Constraint::set_fk_upd_action(const std::string& value) {
  _internal_set_fk_upd_action(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.fk_upd_action)
}
inline std::string* Constraint::mutable_fk_upd_action() {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.fk_upd_action)
  return _internal_mutable_fk_upd_action();
}
inline const std::string& Constraint::_internal_fk_upd_action() const {
  return fk_upd_action_.Get();
}
inline void Constraint::_internal_set_fk_upd_action(const std::string& value) {
  
  fk_upd_action_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Constraint::set_fk_upd_action(std::string&& value) {
  
  fk_upd_action_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.Constraint.fk_upd_action)
}
inline void Constraint::set_fk_upd_action(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  fk_upd_action_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.Constraint.fk_upd_action)
}
inline void Constraint::set_fk_upd_action(const char* value,
    size_t size) {
  
  fk_upd_action_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.Constraint.fk_upd_action)
}
inline std::string* Constraint::_internal_mutable_fk_upd_action() {
  
  return fk_upd_action_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Constraint::release_fk_upd_action() {
  // @@protoc_insertion_point(field_release:pg_query.Constraint.fk_upd_action)
  return fk_upd_action_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Constraint::set_allocated_fk_upd_action(std::string* fk_upd_action) {
  if (fk_upd_action != nullptr) {
    
  } else {
    
  }
  fk_upd_action_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fk_upd_action,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.fk_upd_action)
}

// string fk_del_action = 24 [json_name = "fk_del_action"];
inline void Constraint::clear_fk_del_action() {
  fk_del_action_.ClearToEmpty();
}
inline const std::string& Constraint::fk_del_action() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_del_action)
  return _internal_fk_del_action();
}
inline void Constraint::set_fk_del_action(const std::string& value) {
  _internal_set_fk_del_action(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.fk_del_action)
}
inline std::string* Constraint::mutable_fk_del_action() {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.fk_del_action)
  return _internal_mutable_fk_del_action();
}
inline const std::string& Constraint::_internal_fk_del_action() const {
  return fk_del_action_.Get();
}
inline void Constraint::_internal_set_fk_del_action(const std::string& value) {
  
  fk_del_action_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Constraint::set_fk_del_action(std::string&& value) {
  
  fk_del_action_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.Constraint.fk_del_action)
}
inline void Constraint::set_fk_del_action(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  fk_del_action_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.Constraint.fk_del_action)
}
inline void Constraint::set_fk_del_action(const char* value,
    size_t size) {
  
  fk_del_action_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.Constraint.fk_del_action)
}
inline std::string* Constraint::_internal_mutable_fk_del_action() {
  
  return fk_del_action_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Constraint::release_fk_del_action() {
  // @@protoc_insertion_point(field_release:pg_query.Constraint.fk_del_action)
  return fk_del_action_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Constraint::set_allocated_fk_del_action(std::string* fk_del_action) {
  if (fk_del_action != nullptr) {
    
  } else {
    
  }
  fk_del_action_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fk_del_action,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.fk_del_action)
}

// repeated .pg_query.Node old_conpfeqop = 25 [json_name = "old_conpfeqop"];
inline int Constraint::_internal_old_conpfeqop_size() const {
  return old_conpfeqop_.size();
}
inline int Constraint::old_conpfeqop_size() const {
  return _internal_old_conpfeqop_size();
}
inline void Constraint::clear_old_conpfeqop() {
  old_conpfeqop_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_old_conpfeqop(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.old_conpfeqop)
  return old_conpfeqop_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
Constraint::mutable_old_conpfeqop() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.old_conpfeqop)
  return &old_conpfeqop_;
}
inline const ::pg_query::Node& Constraint::_internal_old_conpfeqop(int index) const {
  return old_conpfeqop_.Get(index);
}
inline const ::pg_query::Node& Constraint::old_conpfeqop(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.old_conpfeqop)
  return _internal_old_conpfeqop(index);
}
inline ::pg_query::Node* Constraint::_internal_add_old_conpfeqop() {
  return old_conpfeqop_.Add();
}
inline ::pg_query::Node* Constraint::add_old_conpfeqop() {
  // @@protoc_insertion_point(field_add:pg_query.Constraint.old_conpfeqop)
  return _internal_add_old_conpfeqop();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
Constraint::old_conpfeqop() const {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.old_conpfeqop)
  return old_conpfeqop_;
}

// uint32 old_pktable_oid = 26 [json_name = "old_pktable_oid"];
inline void Constraint::clear_old_pktable_oid() {
  old_pktable_oid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Constraint::_internal_old_pktable_oid() const {
  return old_pktable_oid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Constraint::old_pktable_oid() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.old_pktable_oid)
  return _internal_old_pktable_oid();
}
inline void Constraint::_internal_set_old_pktable_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  old_pktable_oid_ = value;
}
inline void Constraint::set_old_pktable_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_old_pktable_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.old_pktable_oid)
}

// bool skip_validation = 27 [json_name = "skip_validation"];
inline void Constraint::clear_skip_validation() {
  skip_validation_ = false;
}
inline bool Constraint::_internal_skip_validation() const {
  return skip_validation_;
}
inline bool Constraint::skip_validation() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.skip_validation)
  return _internal_skip_validation();
}
inline void Constraint::_internal_set_skip_validation(bool value) {
  
  skip_validation_ = value;
}
inline void Constraint::set_skip_validation(bool value) {
  _internal_set_skip_validation(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.skip_validation)
}

// bool initially_valid = 28 [json_name = "initially_valid"];
inline void Constraint::clear_initially_valid() {
  initially_valid_ = false;
}
inline bool Constraint::_internal_initially_valid() const {
  return initially_valid_;
}
inline bool Constraint::initially_valid() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.initially_valid)
  return _internal_initially_valid();
}
inline void Constraint::_internal_set_initially_valid(bool value) {
  
  initially_valid_ = value;
}
inline void Constraint::set_initially_valid(bool value) {
  _internal_set_initially_valid(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.initially_valid)
}

// -------------------------------------------------------------------

// DefElem

// string defnamespace = 1 [json_name = "defnamespace"];
inline void DefElem::clear_defnamespace() {
  defnamespace_.ClearToEmpty();
}
inline const std::string& DefElem::defnamespace() const {
  // @@protoc_insertion_point(field_get:pg_query.DefElem.defnamespace)
  return _internal_defnamespace();
}
inline void DefElem::set_defnamespace(const std::string& value) {
  _internal_set_defnamespace(value);
  // @@protoc_insertion_point(field_set:pg_query.DefElem.defnamespace)
}
inline std::string* DefElem::mutable_defnamespace() {
  // @@protoc_insertion_point(field_mutable:pg_query.DefElem.defnamespace)
  return _internal_mutable_defnamespace();
}
inline const std::string& DefElem::_internal_defnamespace() const {
  return defnamespace_.Get();
}
inline void DefElem::_internal_set_defnamespace(const std::string& value) {
  
  defnamespace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void DefElem::set_defnamespace(std::string&& value) {
  
  defnamespace_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.DefElem.defnamespace)
}
inline void DefElem::set_defnamespace(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  defnamespace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.DefElem.defnamespace)
}
inline void DefElem::set_defnamespace(const char* value,
    size_t size) {
  
  defnamespace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.DefElem.defnamespace)
}
inline std::string* DefElem::_internal_mutable_defnamespace() {
  
  return defnamespace_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* DefElem::release_defnamespace() {
  // @@protoc_insertion_point(field_release:pg_query.DefElem.defnamespace)
  return defnamespace_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void DefElem::set_allocated_defnamespace(std::string* defnamespace) {
  if (defnamespace != nullptr) {
    
  } else {
    
  }
  defnamespace_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), defnamespace,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.DefElem.defnamespace)
}

// string defname = 2 [json_name = "defname"];
inline void DefElem::clear_defname() {
  defname_.ClearToEmpty();
}
inline const std::string& DefElem::defname() const {
  // @@protoc_insertion_point(field_get:pg_query.DefElem.defname)
  return _internal_defname();
}
inline void DefElem::set_defname(const std::string& value) {
  _internal_set_defname(value);
  // @@protoc_insertion_point(field_set:pg_query.DefElem.defname)
}
inline std::string* DefElem::mutable_defname() {
  // @@protoc_insertion_point(field_mutable:pg_query.DefElem.defname)
  return _internal_mutable_defname();
}
inline const std::string& DefElem::_internal_defname() const {
  return defname_.Get();
}
inline void DefElem::_internal_set_defname(const std::string& value) {
  
  defname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void DefElem::set_defname(std::string&& value) {
  
  defname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.DefElem.defname)
}
inline void DefElem::set_defname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  defname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.DefElem.defname)
}
inline void DefElem::set_defname(const char* value,
    size_t size) {
  
  defname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.DefElem.defname)
}
inline std::string* DefElem::_internal_mutable_defname() {
  
  return defname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* DefElem::release_defname() {
  // @@protoc_insertion_point(field_release:pg_query.DefElem.defname)
  return defname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void DefElem::set_allocated_defname(std::string* defname) {
  if (defname != nullptr) {
    
  } else {
    
  }
  defname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), defname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.DefElem.defname)
}

// .pg_query.Node arg = 3 [json_name = "arg"];
inline bool DefElem::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool DefElem::has_arg() const {
  return _internal_has_arg();
}
inline void DefElem::clear_arg() {
  if (GetArena() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::pg_query::Node& DefElem::_internal_arg() const {
  const ::pg_query::Node* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& DefElem::arg() const {
  // @@protoc_insertion_point(field_get:pg_query.DefElem.arg)
  return _internal_arg();
}
inline void DefElem::unsafe_arena_set_allocated_arg(
    ::pg_query::Node* arg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DefElem.arg)
}
inline ::pg_query::Node* DefElem::release_arg() {
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* DefElem::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:pg_query.DefElem.arg)
  
  ::pg_query::Node* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* DefElem::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    arg_ = p;
  }
  return arg_;
}
inline ::pg_query::Node* DefElem::mutable_arg() {
  // @@protoc_insertion_point(field_mutable:pg_query.DefElem.arg)
  return _internal_mutable_arg();
}
inline void DefElem::set_allocated_arg(::pg_query::Node* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:pg_query.DefElem.arg)
}

// .pg_query.DefElemAction defaction = 4 [json_name = "defaction"];
inline void DefElem::clear_defaction() {
  defaction_ = 0;
}
inline ::pg_query::DefElemAction DefElem::_internal_defaction() const {
  return static_cast< ::pg_query::DefElemAction >(defaction_);
}
inline ::pg_query::DefElemAction DefElem::defaction() const {
  // @@protoc_insertion_point(field_get:pg_query.DefElem.defaction)
  return _internal_defaction();
}
inline void DefElem::_internal_set_defaction(::pg_query::DefElemAction value) {
  
  defaction_ = value;
}
inline void DefElem::set_defaction(::pg_query::DefElemAction value) {
  _internal_set_defaction(value);
  // @@protoc_insertion_point(field_set:pg_query.DefElem.defaction)
}

// int32 location = 5 [json_name = "location"];
inline void DefElem::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DefElem::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DefElem::location() const {
  // @@protoc_insertion_point(field_get:pg_query.DefElem.location)
  return _internal_location();
}
inline void DefElem::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void DefElem::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.DefElem.location)
}

// -------------------------------------------------------------------

// RangeTblEntry

// .pg_query.RTEKind rtekind = 1 [json_name = "rtekind"];
inline void RangeTblEntry::clear_rtekind() {
  rtekind_ = 0;
}
inline ::pg_query::RTEKind RangeTblEntry::_internal_rtekind() const {
  return static_cast< ::pg_query::RTEKind >(rtekind_);
}
inline ::pg_query::RTEKind RangeTblEntry::rtekind() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.rtekind)
  return _internal_rtekind();
}
inline void RangeTblEntry::_internal_set_rtekind(::pg_query::RTEKind value) {
  
  rtekind_ = value;
}
inline void RangeTblEntry::set_rtekind(::pg_query::RTEKind value) {
  _internal_set_rtekind(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.rtekind)
}

// uint32 relid = 2 [json_name = "relid"];
inline void RangeTblEntry::clear_relid() {
  relid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RangeTblEntry::_internal_relid() const {
  return relid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RangeTblEntry::relid() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.relid)
  return _internal_relid();
}
inline void RangeTblEntry::_internal_set_relid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  relid_ = value;
}
inline void RangeTblEntry::set_relid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_relid(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.relid)
}

// string relkind = 3 [json_name = "relkind"];
inline void RangeTblEntry::clear_relkind() {
  relkind_.ClearToEmpty();
}
inline const std::string& RangeTblEntry::relkind() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.relkind)
  return _internal_relkind();
}
inline void RangeTblEntry::set_relkind(const std::string& value) {
  _internal_set_relkind(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.relkind)
}
inline std::string* RangeTblEntry::mutable_relkind() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.relkind)
  return _internal_mutable_relkind();
}
inline const std::string& RangeTblEntry::_internal_relkind() const {
  return relkind_.Get();
}
inline void RangeTblEntry::_internal_set_relkind(const std::string& value) {
  
  relkind_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RangeTblEntry::set_relkind(std::string&& value) {
  
  relkind_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.RangeTblEntry.relkind)
}
inline void RangeTblEntry::set_relkind(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  relkind_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.RangeTblEntry.relkind)
}
inline void RangeTblEntry::set_relkind(const char* value,
    size_t size) {
  
  relkind_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.RangeTblEntry.relkind)
}
inline std::string* RangeTblEntry::_internal_mutable_relkind() {
  
  return relkind_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RangeTblEntry::release_relkind() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.relkind)
  return relkind_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RangeTblEntry::set_allocated_relkind(std::string* relkind) {
  if (relkind != nullptr) {
    
  } else {
    
  }
  relkind_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), relkind,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.relkind)
}

// int32 rellockmode = 4 [json_name = "rellockmode"];
inline void RangeTblEntry::clear_rellockmode() {
  rellockmode_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTblEntry::_internal_rellockmode() const {
  return rellockmode_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTblEntry::rellockmode() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.rellockmode)
  return _internal_rellockmode();
}
inline void RangeTblEntry::_internal_set_rellockmode(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  rellockmode_ = value;
}
inline void RangeTblEntry::set_rellockmode(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_rellockmode(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.rellockmode)
}

// .pg_query.TableSampleClause tablesample = 5 [json_name = "tablesample"];
inline bool RangeTblEntry::_internal_has_tablesample() const {
  return this != internal_default_instance() && tablesample_ != nullptr;
}
inline bool RangeTblEntry::has_tablesample() const {
  return _internal_has_tablesample();
}
inline void RangeTblEntry::clear_tablesample() {
  if (GetArena() == nullptr && tablesample_ != nullptr) {
    delete tablesample_;
  }
  tablesample_ = nullptr;
}
inline const ::pg_query::TableSampleClause& RangeTblEntry::_internal_tablesample() const {
  const ::pg_query::TableSampleClause* p = tablesample_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TableSampleClause&>(
      ::pg_query::_TableSampleClause_default_instance_);
}
inline const ::pg_query::TableSampleClause& RangeTblEntry::tablesample() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.tablesample)
  return _internal_tablesample();
}
inline void RangeTblEntry::unsafe_arena_set_allocated_tablesample(
    ::pg_query::TableSampleClause* tablesample) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tablesample_);
  }
  tablesample_ = tablesample;
  if (tablesample) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.tablesample)
}
inline ::pg_query::TableSampleClause* RangeTblEntry::release_tablesample() {
  
  ::pg_query::TableSampleClause* temp = tablesample_;
  tablesample_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TableSampleClause* RangeTblEntry::unsafe_arena_release_tablesample() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.tablesample)
  
  ::pg_query::TableSampleClause* temp = tablesample_;
  tablesample_ = nullptr;
  return temp;
}
inline ::pg_query::TableSampleClause* RangeTblEntry::_internal_mutable_tablesample() {
  
  if (tablesample_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TableSampleClause>(GetArena());
    tablesample_ = p;
  }
  return tablesample_;
}
inline ::pg_query::TableSampleClause* RangeTblEntry::mutable_tablesample() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.tablesample)
  return _internal_mutable_tablesample();
}
inline void RangeTblEntry::set_allocated_tablesample(::pg_query::TableSampleClause* tablesample) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete tablesample_;
  }
  if (tablesample) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tablesample);
    if (message_arena != submessage_arena) {
      tablesample = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tablesample, submessage_arena);
    }
    
  } else {
    
  }
  tablesample_ = tablesample;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.tablesample)
}

// .pg_query.Query subquery = 6 [json_name = "subquery"];
inline bool RangeTblEntry::_internal_has_subquery() const {
  return this != internal_default_instance() && subquery_ != nullptr;
}
inline bool RangeTblEntry::has_subquery() const {
  return _internal_has_subquery();
}
inline void RangeTblEntry::clear_subquery() {
  if (GetArena() == nullptr && subquery_ != nullptr) {
    delete subquery_;
  }
  subquery_ = nullptr;
}
inline const ::pg_query::Query& RangeTblEntry::_internal_subquery() const {
  const ::pg_query::Query* p = subquery_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Query&>(
      ::pg_query::_Query_default_instance_);
}
inline const ::pg_query::Query& RangeTblEntry::subquery() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.subquery)
  return _internal_subquery();
}
inline void RangeTblEntry::unsafe_arena_set_allocated_subquery(
    ::pg_query::Query* subquery) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(subquery_);
  }
  subquery_ = subquery;
  if (subquery) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.subquery)
}
inline ::pg_query::Query* RangeTblEntry::release_subquery() {
  
  ::pg_query::Query* temp = subquery_;
  subquery_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Query* RangeTblEntry::unsafe_arena_release_subquery() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.subquery)
  
  ::pg_query::Query* temp = subquery_;
  subquery_ = nullptr;
  return temp;
}
inline ::pg_query::Query* RangeTblEntry::_internal_mutable_subquery() {
  
  if (subquery_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Query>(GetArena());
    subquery_ = p;
  }
  return subquery_;
}
inline ::pg_query::Query* RangeTblEntry::mutable_subquery() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.subquery)
  return _internal_mutable_subquery();
}
inline void RangeTblEntry::set_allocated_subquery(::pg_query::Query* subquery) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete subquery_;
  }
  if (subquery) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(subquery);
    if (message_arena != submessage_arena) {
      subquery = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, subquery, submessage_arena);
    }
    
  } else {
    
  }
  subquery_ = subquery;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.subquery)
}

// bool security_barrier = 7 [json_name = "security_barrier"];
inline void RangeTblEntry::clear_security_barrier() {
  security_barrier_ = false;
}
inline bool RangeTblEntry::_internal_security_barrier() const {
  return security_barrier_;
}
inline bool RangeTblEntry::security_barrier() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.security_barrier)
  return _internal_security_barrier();
}
inline void RangeTblEntry::_internal_set_security_barrier(bool value) {
  
  security_barrier_ = value;
}
inline void RangeTblEntry::set_security_barrier(bool value) {
  _internal_set_security_barrier(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.security_barrier)
}

// .pg_query.JoinType jointype = 8 [json_name = "jointype"];
inline void RangeTblEntry::clear_jointype() {
  jointype_ = 0;
}
inline ::pg_query::JoinType RangeTblEntry::_internal_jointype() const {
  return static_cast< ::pg_query::JoinType >(jointype_);
}
inline ::pg_query::JoinType RangeTblEntry::jointype() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.jointype)
  return _internal_jointype();
}
inline void RangeTblEntry::_internal_set_jointype(::pg_query::JoinType value) {
  
  jointype_ = value;
}
inline void RangeTblEntry::set_jointype(::pg_query::JoinType value) {
  _internal_set_jointype(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.jointype)
}

// int32 joinmergedcols = 9 [json_name = "joinmergedcols"];
inline void RangeTblEntry::clear_joinmergedcols() {
  joinmergedcols_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTblEntry::_internal_joinmergedcols() const {
  return joinmergedcols_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTblEntry::joinmergedcols() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.joinmergedcols)
  return _internal_joinmergedcols();
}
inline void RangeTblEntry::_internal_set_joinmergedcols(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  joinmergedcols_ = value;
}
inline void RangeTblEntry::set_joinmergedcols(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_joinmergedcols(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.joinmergedcols)
}

// repeated .pg_query.Node joinaliasvars = 10 [json_name = "joinaliasvars"];
inline int RangeTblEntry::_internal_joinaliasvars_size() const {
  return joinaliasvars_.size();
}
inline int RangeTblEntry::joinaliasvars_size() const {
  return _internal_joinaliasvars_size();
}
inline void RangeTblEntry::clear_joinaliasvars() {
  joinaliasvars_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_joinaliasvars(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.joinaliasvars)
  return joinaliasvars_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTblEntry::mutable_joinaliasvars() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.joinaliasvars)
  return &joinaliasvars_;
}
inline const ::pg_query::Node& RangeTblEntry::_internal_joinaliasvars(int index) const {
  return joinaliasvars_.Get(index);
}
inline const ::pg_query::Node& RangeTblEntry::joinaliasvars(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.joinaliasvars)
  return _internal_joinaliasvars(index);
}
inline ::pg_query::Node* RangeTblEntry::_internal_add_joinaliasvars() {
  return joinaliasvars_.Add();
}
inline ::pg_query::Node* RangeTblEntry::add_joinaliasvars() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.joinaliasvars)
  return _internal_add_joinaliasvars();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTblEntry::joinaliasvars() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.joinaliasvars)
  return joinaliasvars_;
}

// repeated .pg_query.Node joinleftcols = 11 [json_name = "joinleftcols"];
inline int RangeTblEntry::_internal_joinleftcols_size() const {
  return joinleftcols_.size();
}
inline int RangeTblEntry::joinleftcols_size() const {
  return _internal_joinleftcols_size();
}
inline void RangeTblEntry::clear_joinleftcols() {
  joinleftcols_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_joinleftcols(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.joinleftcols)
  return joinleftcols_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTblEntry::mutable_joinleftcols() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.joinleftcols)
  return &joinleftcols_;
}
inline const ::pg_query::Node& RangeTblEntry::_internal_joinleftcols(int index) const {
  return joinleftcols_.Get(index);
}
inline const ::pg_query::Node& RangeTblEntry::joinleftcols(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.joinleftcols)
  return _internal_joinleftcols(index);
}
inline ::pg_query::Node* RangeTblEntry::_internal_add_joinleftcols() {
  return joinleftcols_.Add();
}
inline ::pg_query::Node* RangeTblEntry::add_joinleftcols() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.joinleftcols)
  return _internal_add_joinleftcols();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTblEntry::joinleftcols() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.joinleftcols)
  return joinleftcols_;
}

// repeated .pg_query.Node joinrightcols = 12 [json_name = "joinrightcols"];
inline int RangeTblEntry::_internal_joinrightcols_size() const {
  return joinrightcols_.size();
}
inline int RangeTblEntry::joinrightcols_size() const {
  return _internal_joinrightcols_size();
}
inline void RangeTblEntry::clear_joinrightcols() {
  joinrightcols_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_joinrightcols(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.joinrightcols)
  return joinrightcols_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTblEntry::mutable_joinrightcols() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.joinrightcols)
  return &joinrightcols_;
}
inline const ::pg_query::Node& RangeTblEntry::_internal_joinrightcols(int index) const {
  return joinrightcols_.Get(index);
}
inline const ::pg_query::Node& RangeTblEntry::joinrightcols(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.joinrightcols)
  return _internal_joinrightcols(index);
}
inline ::pg_query::Node* RangeTblEntry::_internal_add_joinrightcols() {
  return joinrightcols_.Add();
}
inline ::pg_query::Node* RangeTblEntry::add_joinrightcols() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.joinrightcols)
  return _internal_add_joinrightcols();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTblEntry::joinrightcols() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.joinrightcols)
  return joinrightcols_;
}

// repeated .pg_query.Node functions = 13 [json_name = "functions"];
inline int RangeTblEntry::_internal_functions_size() const {
  return functions_.size();
}
inline int RangeTblEntry::functions_size() const {
  return _internal_functions_size();
}
inline void RangeTblEntry::clear_functions() {
  functions_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_functions(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.functions)
  return functions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTblEntry::mutable_functions() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.functions)
  return &functions_;
}
inline const ::pg_query::Node& RangeTblEntry::_internal_functions(int index) const {
  return functions_.Get(index);
}
inline const ::pg_query::Node& RangeTblEntry::functions(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.functions)
  return _internal_functions(index);
}
inline ::pg_query::Node* RangeTblEntry::_internal_add_functions() {
  return functions_.Add();
}
inline ::pg_query::Node* RangeTblEntry::add_functions() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.functions)
  return _internal_add_functions();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTblEntry::functions() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.functions)
  return functions_;
}

// bool funcordinality = 14 [json_name = "funcordinality"];
inline void RangeTblEntry::clear_funcordinality() {
  funcordinality_ = false;
}
inline bool RangeTblEntry::_internal_funcordinality() const {
  return funcordinality_;
}
inline bool RangeTblEntry::funcordinality() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.funcordinality)
  return _internal_funcordinality();
}
inline void RangeTblEntry::_internal_set_funcordinality(bool value) {
  
  funcordinality_ = value;
}
inline void RangeTblEntry::set_funcordinality(bool value) {
  _internal_set_funcordinality(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.funcordinality)
}

// .pg_query.TableFunc tablefunc = 15 [json_name = "tablefunc"];
inline bool RangeTblEntry::_internal_has_tablefunc() const {
  return this != internal_default_instance() && tablefunc_ != nullptr;
}
inline bool RangeTblEntry::has_tablefunc() const {
  return _internal_has_tablefunc();
}
inline void RangeTblEntry::clear_tablefunc() {
  if (GetArena() == nullptr && tablefunc_ != nullptr) {
    delete tablefunc_;
  }
  tablefunc_ = nullptr;
}
inline const ::pg_query::TableFunc& RangeTblEntry::_internal_tablefunc() const {
  const ::pg_query::TableFunc* p = tablefunc_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TableFunc&>(
      ::pg_query::_TableFunc_default_instance_);
}
inline const ::pg_query::TableFunc& RangeTblEntry::tablefunc() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.tablefunc)
  return _internal_tablefunc();
}
inline void RangeTblEntry::unsafe_arena_set_allocated_tablefunc(
    ::pg_query::TableFunc* tablefunc) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tablefunc_);
  }
  tablefunc_ = tablefunc;
  if (tablefunc) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.tablefunc)
}
inline ::pg_query::TableFunc* RangeTblEntry::release_tablefunc() {
  
  ::pg_query::TableFunc* temp = tablefunc_;
  tablefunc_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TableFunc* RangeTblEntry::unsafe_arena_release_tablefunc() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.tablefunc)
  
  ::pg_query::TableFunc* temp = tablefunc_;
  tablefunc_ = nullptr;
  return temp;
}
inline ::pg_query::TableFunc* RangeTblEntry::_internal_mutable_tablefunc() {
  
  if (tablefunc_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TableFunc>(GetArena());
    tablefunc_ = p;
  }
  return tablefunc_;
}
inline ::pg_query::TableFunc* RangeTblEntry::mutable_tablefunc() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.tablefunc)
  return _internal_mutable_tablefunc();
}
inline void RangeTblEntry::set_allocated_tablefunc(::pg_query::TableFunc* tablefunc) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete tablefunc_;
  }
  if (tablefunc) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tablefunc);
    if (message_arena != submessage_arena) {
      tablefunc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tablefunc, submessage_arena);
    }
    
  } else {
    
  }
  tablefunc_ = tablefunc;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.tablefunc)
}

// repeated .pg_query.Node values_lists = 16 [json_name = "values_lists"];
inline int RangeTblEntry::_internal_values_lists_size() const {
  return values_lists_.size();
}
inline int RangeTblEntry::values_lists_size() const {
  return _internal_values_lists_size();
}
inline void RangeTblEntry::clear_values_lists() {
  values_lists_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_values_lists(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.values_lists)
  return values_lists_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTblEntry::mutable_values_lists() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.values_lists)
  return &values_lists_;
}
inline const ::pg_query::Node& RangeTblEntry::_internal_values_lists(int index) const {
  return values_lists_.Get(index);
}
inline const ::pg_query::Node& RangeTblEntry::values_lists(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.values_lists)
  return _internal_values_lists(index);
}
inline ::pg_query::Node* RangeTblEntry::_internal_add_values_lists() {
  return values_lists_.Add();
}
inline ::pg_query::Node* RangeTblEntry::add_values_lists() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.values_lists)
  return _internal_add_values_lists();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTblEntry::values_lists() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.values_lists)
  return values_lists_;
}

// string ctename = 17 [json_name = "ctename"];
inline void RangeTblEntry::clear_ctename() {
  ctename_.ClearToEmpty();
}
inline const std::string& RangeTblEntry::ctename() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.ctename)
  return _internal_ctename();
}
inline void RangeTblEntry::set_ctename(const std::string& value) {
  _internal_set_ctename(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.ctename)
}
inline std::string* RangeTblEntry::mutable_ctename() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.ctename)
  return _internal_mutable_ctename();
}
inline const std::string& RangeTblEntry::_internal_ctename() const {
  return ctename_.Get();
}
inline void RangeTblEntry::_internal_set_ctename(const std::string& value) {
  
  ctename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RangeTblEntry::set_ctename(std::string&& value) {
  
  ctename_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.RangeTblEntry.ctename)
}
inline void RangeTblEntry::set_ctename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  ctename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.RangeTblEntry.ctename)
}
inline void RangeTblEntry::set_ctename(const char* value,
    size_t size) {
  
  ctename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.RangeTblEntry.ctename)
}
inline std::string* RangeTblEntry::_internal_mutable_ctename() {
  
  return ctename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RangeTblEntry::release_ctename() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.ctename)
  return ctename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RangeTblEntry::set_allocated_ctename(std::string* ctename) {
  if (ctename != nullptr) {
    
  } else {
    
  }
  ctename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ctename,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.ctename)
}

// uint32 ctelevelsup = 18 [json_name = "ctelevelsup"];
inline void RangeTblEntry::clear_ctelevelsup() {
  ctelevelsup_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RangeTblEntry::_internal_ctelevelsup() const {
  return ctelevelsup_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RangeTblEntry::ctelevelsup() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.ctelevelsup)
  return _internal_ctelevelsup();
}
inline void RangeTblEntry::_internal_set_ctelevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  ctelevelsup_ = value;
}
inline void RangeTblEntry::set_ctelevelsup(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_ctelevelsup(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.ctelevelsup)
}

// bool self_reference = 19 [json_name = "self_reference"];
inline void RangeTblEntry::clear_self_reference() {
  self_reference_ = false;
}
inline bool RangeTblEntry::_internal_self_reference() const {
  return self_reference_;
}
inline bool RangeTblEntry::self_reference() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.self_reference)
  return _internal_self_reference();
}
inline void RangeTblEntry::_internal_set_self_reference(bool value) {
  
  self_reference_ = value;
}
inline void RangeTblEntry::set_self_reference(bool value) {
  _internal_set_self_reference(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.self_reference)
}

// repeated .pg_query.Node coltypes = 20 [json_name = "coltypes"];
inline int RangeTblEntry::_internal_coltypes_size() const {
  return coltypes_.size();
}
inline int RangeTblEntry::coltypes_size() const {
  return _internal_coltypes_size();
}
inline void RangeTblEntry::clear_coltypes() {
  coltypes_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_coltypes(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.coltypes)
  return coltypes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTblEntry::mutable_coltypes() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.coltypes)
  return &coltypes_;
}
inline const ::pg_query::Node& RangeTblEntry::_internal_coltypes(int index) const {
  return coltypes_.Get(index);
}
inline const ::pg_query::Node& RangeTblEntry::coltypes(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.coltypes)
  return _internal_coltypes(index);
}
inline ::pg_query::Node* RangeTblEntry::_internal_add_coltypes() {
  return coltypes_.Add();
}
inline ::pg_query::Node* RangeTblEntry::add_coltypes() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.coltypes)
  return _internal_add_coltypes();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTblEntry::coltypes() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.coltypes)
  return coltypes_;
}

// repeated .pg_query.Node coltypmods = 21 [json_name = "coltypmods"];
inline int RangeTblEntry::_internal_coltypmods_size() const {
  return coltypmods_.size();
}
inline int RangeTblEntry::coltypmods_size() const {
  return _internal_coltypmods_size();
}
inline void RangeTblEntry::clear_coltypmods() {
  coltypmods_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_coltypmods(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.coltypmods)
  return coltypmods_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTblEntry::mutable_coltypmods() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.coltypmods)
  return &coltypmods_;
}
inline const ::pg_query::Node& RangeTblEntry::_internal_coltypmods(int index) const {
  return coltypmods_.Get(index);
}
inline const ::pg_query::Node& RangeTblEntry::coltypmods(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.coltypmods)
  return _internal_coltypmods(index);
}
inline ::pg_query::Node* RangeTblEntry::_internal_add_coltypmods() {
  return coltypmods_.Add();
}
inline ::pg_query::Node* RangeTblEntry::add_coltypmods() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.coltypmods)
  return _internal_add_coltypmods();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTblEntry::coltypmods() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.coltypmods)
  return coltypmods_;
}

// repeated .pg_query.Node colcollations = 22 [json_name = "colcollations"];
inline int RangeTblEntry::_internal_colcollations_size() const {
  return colcollations_.size();
}
inline int RangeTblEntry::colcollations_size() const {
  return _internal_colcollations_size();
}
inline void RangeTblEntry::clear_colcollations() {
  colcollations_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_colcollations(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.colcollations)
  return colcollations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTblEntry::mutable_colcollations() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.colcollations)
  return &colcollations_;
}
inline const ::pg_query::Node& RangeTblEntry::_internal_colcollations(int index) const {
  return colcollations_.Get(index);
}
inline const ::pg_query::Node& RangeTblEntry::colcollations(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.colcollations)
  return _internal_colcollations(index);
}
inline ::pg_query::Node* RangeTblEntry::_internal_add_colcollations() {
  return colcollations_.Add();
}
inline ::pg_query::Node* RangeTblEntry::add_colcollations() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.colcollations)
  return _internal_add_colcollations();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTblEntry::colcollations() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.colcollations)
  return colcollations_;
}

// string enrname = 23 [json_name = "enrname"];
inline void RangeTblEntry::clear_enrname() {
  enrname_.ClearToEmpty();
}
inline const std::string& RangeTblEntry::enrname() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.enrname)
  return _internal_enrname();
}
inline void RangeTblEntry::set_enrname(const std::string& value) {
  _internal_set_enrname(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.enrname)
}
inline std::string* RangeTblEntry::mutable_enrname() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.enrname)
  return _internal_mutable_enrname();
}
inline const std::string& RangeTblEntry::_internal_enrname() const {
  return enrname_.Get();
}
inline void RangeTblEntry::_internal_set_enrname(const std::string& value) {
  
  enrname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RangeTblEntry::set_enrname(std::string&& value) {
  
  enrname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.RangeTblEntry.enrname)
}
inline void RangeTblEntry::set_enrname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  enrname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.RangeTblEntry.enrname)
}
inline void RangeTblEntry::set_enrname(const char* value,
    size_t size) {
  
  enrname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.RangeTblEntry.enrname)
}
inline std::string* RangeTblEntry::_internal_mutable_enrname() {
  
  return enrname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RangeTblEntry::release_enrname() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.enrname)
  return enrname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RangeTblEntry::set_allocated_enrname(std::string* enrname) {
  if (enrname != nullptr) {
    
  } else {
    
  }
  enrname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), enrname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.enrname)
}

// double enrtuples = 24 [json_name = "enrtuples"];
inline void RangeTblEntry::clear_enrtuples() {
  enrtuples_ = 0;
}
inline double RangeTblEntry::_internal_enrtuples() const {
  return enrtuples_;
}
inline double RangeTblEntry::enrtuples() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.enrtuples)
  return _internal_enrtuples();
}
inline void RangeTblEntry::_internal_set_enrtuples(double value) {
  
  enrtuples_ = value;
}
inline void RangeTblEntry::set_enrtuples(double value) {
  _internal_set_enrtuples(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.enrtuples)
}

// .pg_query.Alias alias = 25 [json_name = "alias"];
inline bool RangeTblEntry::_internal_has_alias() const {
  return this != internal_default_instance() && alias_ != nullptr;
}
inline bool RangeTblEntry::has_alias() const {
  return _internal_has_alias();
}
inline void RangeTblEntry::clear_alias() {
  if (GetArena() == nullptr && alias_ != nullptr) {
    delete alias_;
  }
  alias_ = nullptr;
}
inline const ::pg_query::Alias& RangeTblEntry::_internal_alias() const {
  const ::pg_query::Alias* p = alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(
      ::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& RangeTblEntry::alias() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.alias)
  return _internal_alias();
}
inline void RangeTblEntry::unsafe_arena_set_allocated_alias(
    ::pg_query::Alias* alias) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alias_);
  }
  alias_ = alias;
  if (alias) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.alias)
}
inline ::pg_query::Alias* RangeTblEntry::release_alias() {
  
  ::pg_query::Alias* temp = alias_;
  alias_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Alias* RangeTblEntry::unsafe_arena_release_alias() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.alias)
  
  ::pg_query::Alias* temp = alias_;
  alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* RangeTblEntry::_internal_mutable_alias() {
  
  if (alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    alias_ = p;
  }
  return alias_;
}
inline ::pg_query::Alias* RangeTblEntry::mutable_alias() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.alias)
  return _internal_mutable_alias();
}
inline void RangeTblEntry::set_allocated_alias(::pg_query::Alias* alias) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete alias_;
  }
  if (alias) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(alias);
    if (message_arena != submessage_arena) {
      alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, alias, submessage_arena);
    }
    
  } else {
    
  }
  alias_ = alias;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.alias)
}

// .pg_query.Alias eref = 26 [json_name = "eref"];
inline bool RangeTblEntry::_internal_has_eref() const {
  return this != internal_default_instance() && eref_ != nullptr;
}
inline bool RangeTblEntry::has_eref() const {
  return _internal_has_eref();
}
inline void RangeTblEntry::clear_eref() {
  if (GetArena() == nullptr && eref_ != nullptr) {
    delete eref_;
  }
  eref_ = nullptr;
}
inline const ::pg_query::Alias& RangeTblEntry::_internal_eref() const {
  const ::pg_query::Alias* p = eref_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(
      ::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& RangeTblEntry::eref() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.eref)
  return _internal_eref();
}
inline void RangeTblEntry::unsafe_arena_set_allocated_eref(
    ::pg_query::Alias* eref) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(eref_);
  }
  eref_ = eref;
  if (eref) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.eref)
}
inline ::pg_query::Alias* RangeTblEntry::release_eref() {
  
  ::pg_query::Alias* temp = eref_;
  eref_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Alias* RangeTblEntry::unsafe_arena_release_eref() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.eref)
  
  ::pg_query::Alias* temp = eref_;
  eref_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* RangeTblEntry::_internal_mutable_eref() {
  
  if (eref_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    eref_ = p;
  }
  return eref_;
}
inline ::pg_query::Alias* RangeTblEntry::mutable_eref() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.eref)
  return _internal_mutable_eref();
}
inline void RangeTblEntry::set_allocated_eref(::pg_query::Alias* eref) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete eref_;
  }
  if (eref) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(eref);
    if (message_arena != submessage_arena) {
      eref = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, eref, submessage_arena);
    }
    
  } else {
    
  }
  eref_ = eref;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.eref)
}

// bool lateral = 27 [json_name = "lateral"];
inline void RangeTblEntry::clear_lateral() {
  lateral_ = false;
}
inline bool RangeTblEntry::_internal_lateral() const {
  return lateral_;
}
inline bool RangeTblEntry::lateral() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.lateral)
  return _internal_lateral();
}
inline void RangeTblEntry::_internal_set_lateral(bool value) {
  
  lateral_ = value;
}
inline void RangeTblEntry::set_lateral(bool value) {
  _internal_set_lateral(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.lateral)
}

// bool inh = 28 [json_name = "inh"];
inline void RangeTblEntry::clear_inh() {
  inh_ = false;
}
inline bool RangeTblEntry::_internal_inh() const {
  return inh_;
}
inline bool RangeTblEntry::inh() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.inh)
  return _internal_inh();
}
inline void RangeTblEntry::_internal_set_inh(bool value) {
  
  inh_ = value;
}
inline void RangeTblEntry::set_inh(bool value) {
  _internal_set_inh(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.inh)
}

// bool in_from_cl = 29 [json_name = "inFromCl"];
inline void RangeTblEntry::clear_in_from_cl() {
  in_from_cl_ = false;
}
inline bool RangeTblEntry::_internal_in_from_cl() const {
  return in_from_cl_;
}
inline bool RangeTblEntry::in_from_cl() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.in_from_cl)
  return _internal_in_from_cl();
}
inline void RangeTblEntry::_internal_set_in_from_cl(bool value) {
  
  in_from_cl_ = value;
}
inline void RangeTblEntry::set_in_from_cl(bool value) {
  _internal_set_in_from_cl(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.in_from_cl)
}

// uint32 required_perms = 30 [json_name = "requiredPerms"];
inline void RangeTblEntry::clear_required_perms() {
  required_perms_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RangeTblEntry::_internal_required_perms() const {
  return required_perms_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RangeTblEntry::required_perms() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.required_perms)
  return _internal_required_perms();
}
inline void RangeTblEntry::_internal_set_required_perms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  required_perms_ = value;
}
inline void RangeTblEntry::set_required_perms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_required_perms(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.required_perms)
}

// uint32 check_as_user = 31 [json_name = "checkAsUser"];
inline void RangeTblEntry::clear_check_as_user() {
  check_as_user_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RangeTblEntry::_internal_check_as_user() const {
  return check_as_user_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RangeTblEntry::check_as_user() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.check_as_user)
  return _internal_check_as_user();
}
inline void RangeTblEntry::_internal_set_check_as_user(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  check_as_user_ = value;
}
inline void RangeTblEntry::set_check_as_user(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_check_as_user(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.check_as_user)
}

// repeated .pg_query.Node security_quals = 32 [json_name = "securityQuals"];
inline int RangeTblEntry::_internal_security_quals_size() const {
  return security_quals_.size();
}
inline int RangeTblEntry::security_quals_size() const {
  return _internal_security_quals_size();
}
inline void RangeTblEntry::clear_security_quals() {
  security_quals_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_security_quals(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.security_quals)
  return security_quals_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTblEntry::mutable_security_quals() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.security_quals)
  return &security_quals_;
}
inline const ::pg_query::Node& RangeTblEntry::_internal_security_quals(int index) const {
  return security_quals_.Get(index);
}
inline const ::pg_query::Node& RangeTblEntry::security_quals(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.security_quals)
  return _internal_security_quals(index);
}
inline ::pg_query::Node* RangeTblEntry::_internal_add_security_quals() {
  return security_quals_.Add();
}
inline ::pg_query::Node* RangeTblEntry::add_security_quals() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.security_quals)
  return _internal_add_security_quals();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTblEntry::security_quals() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.security_quals)
  return security_quals_;
}

// -------------------------------------------------------------------

// RangeTblFunction

// .pg_query.Node funcexpr = 1 [json_name = "funcexpr"];
inline bool RangeTblFunction::_internal_has_funcexpr() const {
  return this != internal_default_instance() && funcexpr_ != nullptr;
}
inline bool RangeTblFunction::has_funcexpr() const {
  return _internal_has_funcexpr();
}
inline void RangeTblFunction::clear_funcexpr() {
  if (GetArena() == nullptr && funcexpr_ != nullptr) {
    delete funcexpr_;
  }
  funcexpr_ = nullptr;
}
inline const ::pg_query::Node& RangeTblFunction::_internal_funcexpr() const {
  const ::pg_query::Node* p = funcexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTblFunction::funcexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funcexpr)
  return _internal_funcexpr();
}
inline void RangeTblFunction::unsafe_arena_set_allocated_funcexpr(
    ::pg_query::Node* funcexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(funcexpr_);
  }
  funcexpr_ = funcexpr;
  if (funcexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblFunction.funcexpr)
}
inline ::pg_query::Node* RangeTblFunction::release_funcexpr() {
  
  ::pg_query::Node* temp = funcexpr_;
  funcexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* RangeTblFunction::unsafe_arena_release_funcexpr() {
  // @@protoc_insertion_point(field_release:pg_query.RangeTblFunction.funcexpr)
  
  ::pg_query::Node* temp = funcexpr_;
  funcexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTblFunction::_internal_mutable_funcexpr() {
  
  if (funcexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    funcexpr_ = p;
  }
  return funcexpr_;
}
inline ::pg_query::Node* RangeTblFunction::mutable_funcexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funcexpr)
  return _internal_mutable_funcexpr();
}
inline void RangeTblFunction::set_allocated_funcexpr(::pg_query::Node* funcexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete funcexpr_;
  }
  if (funcexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(funcexpr);
    if (message_arena != submessage_arena) {
      funcexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, funcexpr, submessage_arena);
    }
    
  } else {
    
  }
  funcexpr_ = funcexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblFunction.funcexpr)
}

// int32 funccolcount = 2 [json_name = "funccolcount"];
inline void RangeTblFunction::clear_funccolcount() {
  funccolcount_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTblFunction::_internal_funccolcount() const {
  return funccolcount_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RangeTblFunction::funccolcount() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccolcount)
  return _internal_funccolcount();
}
inline void RangeTblFunction::_internal_set_funccolcount(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  funccolcount_ = value;
}
inline void RangeTblFunction::set_funccolcount(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_funccolcount(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblFunction.funccolcount)
}

// repeated .pg_query.Node funccolnames = 3 [json_name = "funccolnames"];
inline int RangeTblFunction::_internal_funccolnames_size() const {
  return funccolnames_.size();
}
inline int RangeTblFunction::funccolnames_size() const {
  return _internal_funccolnames_size();
}
inline void RangeTblFunction::clear_funccolnames() {
  funccolnames_.Clear();
}
inline ::pg_query::Node* RangeTblFunction::mutable_funccolnames(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funccolnames)
  return funccolnames_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTblFunction::mutable_funccolnames() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funccolnames)
  return &funccolnames_;
}
inline const ::pg_query::Node& RangeTblFunction::_internal_funccolnames(int index) const {
  return funccolnames_.Get(index);
}
inline const ::pg_query::Node& RangeTblFunction::funccolnames(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccolnames)
  return _internal_funccolnames(index);
}
inline ::pg_query::Node* RangeTblFunction::_internal_add_funccolnames() {
  return funccolnames_.Add();
}
inline ::pg_query::Node* RangeTblFunction::add_funccolnames() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funccolnames)
  return _internal_add_funccolnames();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTblFunction::funccolnames() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funccolnames)
  return funccolnames_;
}

// repeated .pg_query.Node funccoltypes = 4 [json_name = "funccoltypes"];
inline int RangeTblFunction::_internal_funccoltypes_size() const {
  return funccoltypes_.size();
}
inline int RangeTblFunction::funccoltypes_size() const {
  return _internal_funccoltypes_size();
}
inline void RangeTblFunction::clear_funccoltypes() {
  funccoltypes_.Clear();
}
inline ::pg_query::Node* RangeTblFunction::mutable_funccoltypes(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funccoltypes)
  return funccoltypes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTblFunction::mutable_funccoltypes() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funccoltypes)
  return &funccoltypes_;
}
inline const ::pg_query::Node& RangeTblFunction::_internal_funccoltypes(int index) const {
  return funccoltypes_.Get(index);
}
inline const ::pg_query::Node& RangeTblFunction::funccoltypes(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccoltypes)
  return _internal_funccoltypes(index);
}
inline ::pg_query::Node* RangeTblFunction::_internal_add_funccoltypes() {
  return funccoltypes_.Add();
}
inline ::pg_query::Node* RangeTblFunction::add_funccoltypes() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funccoltypes)
  return _internal_add_funccoltypes();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTblFunction::funccoltypes() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funccoltypes)
  return funccoltypes_;
}

// repeated .pg_query.Node funccoltypmods = 5 [json_name = "funccoltypmods"];
inline int RangeTblFunction::_internal_funccoltypmods_size() const {
  return funccoltypmods_.size();
}
inline int RangeTblFunction::funccoltypmods_size() const {
  return _internal_funccoltypmods_size();
}
inline void RangeTblFunction::clear_funccoltypmods() {
  funccoltypmods_.Clear();
}
inline ::pg_query::Node* RangeTblFunction::mutable_funccoltypmods(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funccoltypmods)
  return funccoltypmods_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTblFunction::mutable_funccoltypmods() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funccoltypmods)
  return &funccoltypmods_;
}
inline const ::pg_query::Node& RangeTblFunction::_internal_funccoltypmods(int index) const {
  return funccoltypmods_.Get(index);
}
inline const ::pg_query::Node& RangeTblFunction::funccoltypmods(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccoltypmods)
  return _internal_funccoltypmods(index);
}
inline ::pg_query::Node* RangeTblFunction::_internal_add_funccoltypmods() {
  return funccoltypmods_.Add();
}
inline ::pg_query::Node* RangeTblFunction::add_funccoltypmods() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funccoltypmods)
  return _internal_add_funccoltypmods();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTblFunction::funccoltypmods() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funccoltypmods)
  return funccoltypmods_;
}

// repeated .pg_query.Node funccolcollations = 6 [json_name = "funccolcollations"];
inline int RangeTblFunction::_internal_funccolcollations_size() const {
  return funccolcollations_.size();
}
inline int RangeTblFunction::funccolcollations_size() const {
  return _internal_funccolcollations_size();
}
inline void RangeTblFunction::clear_funccolcollations() {
  funccolcollations_.Clear();
}
inline ::pg_query::Node* RangeTblFunction::mutable_funccolcollations(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funccolcollations)
  return funccolcollations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
RangeTblFunction::mutable_funccolcollations() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funccolcollations)
  return &funccolcollations_;
}
inline const ::pg_query::Node& RangeTblFunction::_internal_funccolcollations(int index) const {
  return funccolcollations_.Get(index);
}
inline const ::pg_query::Node& RangeTblFunction::funccolcollations(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccolcollations)
  return _internal_funccolcollations(index);
}
inline ::pg_query::Node* RangeTblFunction::_internal_add_funccolcollations() {
  return funccolcollations_.Add();
}
inline ::pg_query::Node* RangeTblFunction::add_funccolcollations() {
  // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funccolcollations)
  return _internal_add_funccolcollations();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
RangeTblFunction::funccolcollations() const {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funccolcollations)
  return funccolcollations_;
}

// -------------------------------------------------------------------

// TableSampleClause

// uint32 tsmhandler = 1 [json_name = "tsmhandler"];
inline void TableSampleClause::clear_tsmhandler() {
  tsmhandler_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TableSampleClause::_internal_tsmhandler() const {
  return tsmhandler_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TableSampleClause::tsmhandler() const {
  // @@protoc_insertion_point(field_get:pg_query.TableSampleClause.tsmhandler)
  return _internal_tsmhandler();
}
inline void TableSampleClause::_internal_set_tsmhandler(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  tsmhandler_ = value;
}
inline void TableSampleClause::set_tsmhandler(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_tsmhandler(value);
  // @@protoc_insertion_point(field_set:pg_query.TableSampleClause.tsmhandler)
}

// repeated .pg_query.Node args = 2 [json_name = "args"];
inline int TableSampleClause::_internal_args_size() const {
  return args_.size();
}
inline int TableSampleClause::args_size() const {
  return _internal_args_size();
}
inline void TableSampleClause::clear_args() {
  args_.Clear();
}
inline ::pg_query::Node* TableSampleClause::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.TableSampleClause.args)
  return args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
TableSampleClause::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableSampleClause.args)
  return &args_;
}
inline const ::pg_query::Node& TableSampleClause::_internal_args(int index) const {
  return args_.Get(index);
}
inline const ::pg_query::Node& TableSampleClause::args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TableSampleClause.args)
  return _internal_args(index);
}
inline ::pg_query::Node* TableSampleClause::_internal_add_args() {
  return args_.Add();
}
inline ::pg_query::Node* TableSampleClause::add_args() {
  // @@protoc_insertion_point(field_add:pg_query.TableSampleClause.args)
  return _internal_add_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
TableSampleClause::args() const {
  // @@protoc_insertion_point(field_list:pg_query.TableSampleClause.args)
  return args_;
}

// .pg_query.Node repeatable = 3 [json_name = "repeatable"];
inline bool TableSampleClause::_internal_has_repeatable() const {
  return this != internal_default_instance() && repeatable_ != nullptr;
}
inline bool TableSampleClause::has_repeatable() const {
  return _internal_has_repeatable();
}
inline void TableSampleClause::clear_repeatable() {
  if (GetArena() == nullptr && repeatable_ != nullptr) {
    delete repeatable_;
  }
  repeatable_ = nullptr;
}
inline const ::pg_query::Node& TableSampleClause::_internal_repeatable() const {
  const ::pg_query::Node* p = repeatable_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& TableSampleClause::repeatable() const {
  // @@protoc_insertion_point(field_get:pg_query.TableSampleClause.repeatable)
  return _internal_repeatable();
}
inline void TableSampleClause::unsafe_arena_set_allocated_repeatable(
    ::pg_query::Node* repeatable) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(repeatable_);
  }
  repeatable_ = repeatable;
  if (repeatable) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TableSampleClause.repeatable)
}
inline ::pg_query::Node* TableSampleClause::release_repeatable() {
  
  ::pg_query::Node* temp = repeatable_;
  repeatable_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* TableSampleClause::unsafe_arena_release_repeatable() {
  // @@protoc_insertion_point(field_release:pg_query.TableSampleClause.repeatable)
  
  ::pg_query::Node* temp = repeatable_;
  repeatable_ = nullptr;
  return temp;
}
inline ::pg_query::Node* TableSampleClause::_internal_mutable_repeatable() {
  
  if (repeatable_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    repeatable_ = p;
  }
  return repeatable_;
}
inline ::pg_query::Node* TableSampleClause::mutable_repeatable() {
  // @@protoc_insertion_point(field_mutable:pg_query.TableSampleClause.repeatable)
  return _internal_mutable_repeatable();
}
inline void TableSampleClause::set_allocated_repeatable(::pg_query::Node* repeatable) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete repeatable_;
  }
  if (repeatable) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(repeatable);
    if (message_arena != submessage_arena) {
      repeatable = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, repeatable, submessage_arena);
    }
    
  } else {
    
  }
  repeatable_ = repeatable;
  // @@protoc_insertion_point(field_set_allocated:pg_query.TableSampleClause.repeatable)
}

// -------------------------------------------------------------------

// WithCheckOption

// .pg_query.WCOKind kind = 1 [json_name = "kind"];
inline void WithCheckOption::clear_kind() {
  kind_ = 0;
}
inline ::pg_query::WCOKind WithCheckOption::_internal_kind() const {
  return static_cast< ::pg_query::WCOKind >(kind_);
}
inline ::pg_query::WCOKind WithCheckOption::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.kind)
  return _internal_kind();
}
inline void WithCheckOption::_internal_set_kind(::pg_query::WCOKind value) {
  
  kind_ = value;
}
inline void WithCheckOption::set_kind(::pg_query::WCOKind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.WithCheckOption.kind)
}

// string relname = 2 [json_name = "relname"];
inline void WithCheckOption::clear_relname() {
  relname_.ClearToEmpty();
}
inline const std::string& WithCheckOption::relname() const {
  // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.relname)
  return _internal_relname();
}
inline void WithCheckOption::set_relname(const std::string& value) {
  _internal_set_relname(value);
  // @@protoc_insertion_point(field_set:pg_query.WithCheckOption.relname)
}
inline std::string* WithCheckOption::mutable_relname() {
  // @@protoc_insertion_point(field_mutable:pg_query.WithCheckOption.relname)
  return _internal_mutable_relname();
}
inline const std::string& WithCheckOption::_internal_relname() const {
  return relname_.Get();
}
inline void WithCheckOption::_internal_set_relname(const std::string& value) {
  
  relname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void WithCheckOption::set_relname(std::string&& value) {
  
  relname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.WithCheckOption.relname)
}
inline void WithCheckOption::set_relname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  relname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.WithCheckOption.relname)
}
inline void WithCheckOption::set_relname(const char* value,
    size_t size) {
  
  relname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.WithCheckOption.relname)
}
inline std::string* WithCheckOption::_internal_mutable_relname() {
  
  return relname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WithCheckOption::release_relname() {
  // @@protoc_insertion_point(field_release:pg_query.WithCheckOption.relname)
  return relname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void WithCheckOption::set_allocated_relname(std::string* relname) {
  if (relname != nullptr) {
    
  } else {
    
  }
  relname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), relname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.WithCheckOption.relname)
}

// string polname = 3 [json_name = "polname"];
inline void WithCheckOption::clear_polname() {
  polname_.ClearToEmpty();
}
inline const std::string& WithCheckOption::polname() const {
  // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.polname)
  return _internal_polname();
}
inline void WithCheckOption::set_polname(const std::string& value) {
  _internal_set_polname(value);
  // @@protoc_insertion_point(field_set:pg_query.WithCheckOption.polname)
}
inline std::string* WithCheckOption::mutable_polname() {
  // @@protoc_insertion_point(field_mutable:pg_query.WithCheckOption.polname)
  return _internal_mutable_polname();
}
inline const std::string& WithCheckOption::_internal_polname() const {
  return polname_.Get();
}
inline void WithCheckOption::_internal_set_polname(const std::string& value) {
  
  polname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void WithCheckOption::set_polname(std::string&& value) {
  
  polname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.WithCheckOption.polname)
}
inline void WithCheckOption::set_polname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  polname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.WithCheckOption.polname)
}
inline void WithCheckOption::set_polname(const char* value,
    size_t size) {
  
  polname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.WithCheckOption.polname)
}
inline std::string* WithCheckOption::_internal_mutable_polname() {
  
  return polname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WithCheckOption::release_polname() {
  // @@protoc_insertion_point(field_release:pg_query.WithCheckOption.polname)
  return polname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void WithCheckOption::set_allocated_polname(std::string* polname) {
  if (polname != nullptr) {
    
  } else {
    
  }
  polname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), polname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.WithCheckOption.polname)
}

// .pg_query.Node qual = 4 [json_name = "qual"];
inline bool WithCheckOption::_internal_has_qual() const {
  return this != internal_default_instance() && qual_ != nullptr;
}
inline bool WithCheckOption::has_qual() const {
  return _internal_has_qual();
}
inline void WithCheckOption::clear_qual() {
  if (GetArena() == nullptr && qual_ != nullptr) {
    delete qual_;
  }
  qual_ = nullptr;
}
inline const ::pg_query::Node& WithCheckOption::_internal_qual() const {
  const ::pg_query::Node* p = qual_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& WithCheckOption::qual() const {
  // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.qual)
  return _internal_qual();
}
inline void WithCheckOption::unsafe_arena_set_allocated_qual(
    ::pg_query::Node* qual) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(qual_);
  }
  qual_ = qual;
  if (qual) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WithCheckOption.qual)
}
inline ::pg_query::Node* WithCheckOption::release_qual() {
  
  ::pg_query::Node* temp = qual_;
  qual_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* WithCheckOption::unsafe_arena_release_qual() {
  // @@protoc_insertion_point(field_release:pg_query.WithCheckOption.qual)
  
  ::pg_query::Node* temp = qual_;
  qual_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WithCheckOption::_internal_mutable_qual() {
  
  if (qual_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    qual_ = p;
  }
  return qual_;
}
inline ::pg_query::Node* WithCheckOption::mutable_qual() {
  // @@protoc_insertion_point(field_mutable:pg_query.WithCheckOption.qual)
  return _internal_mutable_qual();
}
inline void WithCheckOption::set_allocated_qual(::pg_query::Node* qual) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete qual_;
  }
  if (qual) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(qual);
    if (message_arena != submessage_arena) {
      qual = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, qual, submessage_arena);
    }
    
  } else {
    
  }
  qual_ = qual;
  // @@protoc_insertion_point(field_set_allocated:pg_query.WithCheckOption.qual)
}

// bool cascaded = 5 [json_name = "cascaded"];
inline void WithCheckOption::clear_cascaded() {
  cascaded_ = false;
}
inline bool WithCheckOption::_internal_cascaded() const {
  return cascaded_;
}
inline bool WithCheckOption::cascaded() const {
  // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.cascaded)
  return _internal_cascaded();
}
inline void WithCheckOption::_internal_set_cascaded(bool value) {
  
  cascaded_ = value;
}
inline void WithCheckOption::set_cascaded(bool value) {
  _internal_set_cascaded(value);
  // @@protoc_insertion_point(field_set:pg_query.WithCheckOption.cascaded)
}

// -------------------------------------------------------------------

// SortGroupClause

// uint32 tle_sort_group_ref = 1 [json_name = "tleSortGroupRef"];
inline void SortGroupClause::clear_tle_sort_group_ref() {
  tle_sort_group_ref_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SortGroupClause::_internal_tle_sort_group_ref() const {
  return tle_sort_group_ref_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SortGroupClause::tle_sort_group_ref() const {
  // @@protoc_insertion_point(field_get:pg_query.SortGroupClause.tle_sort_group_ref)
  return _internal_tle_sort_group_ref();
}
inline void SortGroupClause::_internal_set_tle_sort_group_ref(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  tle_sort_group_ref_ = value;
}
inline void SortGroupClause::set_tle_sort_group_ref(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_tle_sort_group_ref(value);
  // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.tle_sort_group_ref)
}

// uint32 eqop = 2 [json_name = "eqop"];
inline void SortGroupClause::clear_eqop() {
  eqop_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SortGroupClause::_internal_eqop() const {
  return eqop_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SortGroupClause::eqop() const {
  // @@protoc_insertion_point(field_get:pg_query.SortGroupClause.eqop)
  return _internal_eqop();
}
inline void SortGroupClause::_internal_set_eqop(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  eqop_ = value;
}
inline void SortGroupClause::set_eqop(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_eqop(value);
  // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.eqop)
}

// uint32 sortop = 3 [json_name = "sortop"];
inline void SortGroupClause::clear_sortop() {
  sortop_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SortGroupClause::_internal_sortop() const {
  return sortop_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SortGroupClause::sortop() const {
  // @@protoc_insertion_point(field_get:pg_query.SortGroupClause.sortop)
  return _internal_sortop();
}
inline void SortGroupClause::_internal_set_sortop(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  sortop_ = value;
}
inline void SortGroupClause::set_sortop(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_sortop(value);
  // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.sortop)
}

// bool nulls_first = 4 [json_name = "nulls_first"];
inline void SortGroupClause::clear_nulls_first() {
  nulls_first_ = false;
}
inline bool SortGroupClause::_internal_nulls_first() const {
  return nulls_first_;
}
inline bool SortGroupClause::nulls_first() const {
  // @@protoc_insertion_point(field_get:pg_query.SortGroupClause.nulls_first)
  return _internal_nulls_first();
}
inline void SortGroupClause::_internal_set_nulls_first(bool value) {
  
  nulls_first_ = value;
}
inline void SortGroupClause::set_nulls_first(bool value) {
  _internal_set_nulls_first(value);
  // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.nulls_first)
}

// bool hashable = 5 [json_name = "hashable"];
inline void SortGroupClause::clear_hashable() {
  hashable_ = false;
}
inline bool SortGroupClause::_internal_hashable() const {
  return hashable_;
}
inline bool SortGroupClause::hashable() const {
  // @@protoc_insertion_point(field_get:pg_query.SortGroupClause.hashable)
  return _internal_hashable();
}
inline void SortGroupClause::_internal_set_hashable(bool value) {
  
  hashable_ = value;
}
inline void SortGroupClause::set_hashable(bool value) {
  _internal_set_hashable(value);
  // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.hashable)
}

// -------------------------------------------------------------------

// GroupingSet

// .pg_query.GroupingSetKind kind = 1 [json_name = "kind"];
inline void GroupingSet::clear_kind() {
  kind_ = 0;
}
inline ::pg_query::GroupingSetKind GroupingSet::_internal_kind() const {
  return static_cast< ::pg_query::GroupingSetKind >(kind_);
}
inline ::pg_query::GroupingSetKind GroupingSet::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.GroupingSet.kind)
  return _internal_kind();
}
inline void GroupingSet::_internal_set_kind(::pg_query::GroupingSetKind value) {
  
  kind_ = value;
}
inline void GroupingSet::set_kind(::pg_query::GroupingSetKind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.GroupingSet.kind)
}

// repeated .pg_query.Node content = 2 [json_name = "content"];
inline int GroupingSet::_internal_content_size() const {
  return content_.size();
}
inline int GroupingSet::content_size() const {
  return _internal_content_size();
}
inline void GroupingSet::clear_content() {
  content_.Clear();
}
inline ::pg_query::Node* GroupingSet::mutable_content(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.GroupingSet.content)
  return content_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
GroupingSet::mutable_content() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GroupingSet.content)
  return &content_;
}
inline const ::pg_query::Node& GroupingSet::_internal_content(int index) const {
  return content_.Get(index);
}
inline const ::pg_query::Node& GroupingSet::content(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.GroupingSet.content)
  return _internal_content(index);
}
inline ::pg_query::Node* GroupingSet::_internal_add_content() {
  return content_.Add();
}
inline ::pg_query::Node* GroupingSet::add_content() {
  // @@protoc_insertion_point(field_add:pg_query.GroupingSet.content)
  return _internal_add_content();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
GroupingSet::content() const {
  // @@protoc_insertion_point(field_list:pg_query.GroupingSet.content)
  return content_;
}

// int32 location = 3 [json_name = "location"];
inline void GroupingSet::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GroupingSet::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GroupingSet::location() const {
  // @@protoc_insertion_point(field_get:pg_query.GroupingSet.location)
  return _internal_location();
}
inline void GroupingSet::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void GroupingSet::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.GroupingSet.location)
}

// -------------------------------------------------------------------

// WindowClause

// string name = 1 [json_name = "name"];
inline void WindowClause::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& WindowClause::name() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.name)
  return _internal_name();
}
inline void WindowClause::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.name)
}
inline std::string* WindowClause::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.name)
  return _internal_mutable_name();
}
inline const std::string& WindowClause::_internal_name() const {
  return name_.Get();
}
inline void WindowClause::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void WindowClause::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.WindowClause.name)
}
inline void WindowClause::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.WindowClause.name)
}
inline void WindowClause::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.WindowClause.name)
}
inline std::string* WindowClause::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WindowClause::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.WindowClause.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void WindowClause::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowClause.name)
}

// string refname = 2 [json_name = "refname"];
inline void WindowClause::clear_refname() {
  refname_.ClearToEmpty();
}
inline const std::string& WindowClause::refname() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.refname)
  return _internal_refname();
}
inline void WindowClause::set_refname(const std::string& value) {
  _internal_set_refname(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.refname)
}
inline std::string* WindowClause::mutable_refname() {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.refname)
  return _internal_mutable_refname();
}
inline const std::string& WindowClause::_internal_refname() const {
  return refname_.Get();
}
inline void WindowClause::_internal_set_refname(const std::string& value) {
  
  refname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void WindowClause::set_refname(std::string&& value) {
  
  refname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.WindowClause.refname)
}
inline void WindowClause::set_refname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  refname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.WindowClause.refname)
}
inline void WindowClause::set_refname(const char* value,
    size_t size) {
  
  refname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.WindowClause.refname)
}
inline std::string* WindowClause::_internal_mutable_refname() {
  
  return refname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WindowClause::release_refname() {
  // @@protoc_insertion_point(field_release:pg_query.WindowClause.refname)
  return refname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void WindowClause::set_allocated_refname(std::string* refname) {
  if (refname != nullptr) {
    
  } else {
    
  }
  refname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), refname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowClause.refname)
}

// repeated .pg_query.Node partition_clause = 3 [json_name = "partitionClause"];
inline int WindowClause::_internal_partition_clause_size() const {
  return partition_clause_.size();
}
inline int WindowClause::partition_clause_size() const {
  return _internal_partition_clause_size();
}
inline void WindowClause::clear_partition_clause() {
  partition_clause_.Clear();
}
inline ::pg_query::Node* WindowClause::mutable_partition_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.partition_clause)
  return partition_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
WindowClause::mutable_partition_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.WindowClause.partition_clause)
  return &partition_clause_;
}
inline const ::pg_query::Node& WindowClause::_internal_partition_clause(int index) const {
  return partition_clause_.Get(index);
}
inline const ::pg_query::Node& WindowClause::partition_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.partition_clause)
  return _internal_partition_clause(index);
}
inline ::pg_query::Node* WindowClause::_internal_add_partition_clause() {
  return partition_clause_.Add();
}
inline ::pg_query::Node* WindowClause::add_partition_clause() {
  // @@protoc_insertion_point(field_add:pg_query.WindowClause.partition_clause)
  return _internal_add_partition_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
WindowClause::partition_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.WindowClause.partition_clause)
  return partition_clause_;
}

// repeated .pg_query.Node order_clause = 4 [json_name = "orderClause"];
inline int WindowClause::_internal_order_clause_size() const {
  return order_clause_.size();
}
inline int WindowClause::order_clause_size() const {
  return _internal_order_clause_size();
}
inline void WindowClause::clear_order_clause() {
  order_clause_.Clear();
}
inline ::pg_query::Node* WindowClause::mutable_order_clause(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.order_clause)
  return order_clause_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
WindowClause::mutable_order_clause() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.WindowClause.order_clause)
  return &order_clause_;
}
inline const ::pg_query::Node& WindowClause::_internal_order_clause(int index) const {
  return order_clause_.Get(index);
}
inline const ::pg_query::Node& WindowClause::order_clause(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.order_clause)
  return _internal_order_clause(index);
}
inline ::pg_query::Node* WindowClause::_internal_add_order_clause() {
  return order_clause_.Add();
}
inline ::pg_query::Node* WindowClause::add_order_clause() {
  // @@protoc_insertion_point(field_add:pg_query.WindowClause.order_clause)
  return _internal_add_order_clause();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
WindowClause::order_clause() const {
  // @@protoc_insertion_point(field_list:pg_query.WindowClause.order_clause)
  return order_clause_;
}

// int32 frame_options = 5 [json_name = "frameOptions"];
inline void WindowClause::clear_frame_options() {
  frame_options_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 WindowClause::_internal_frame_options() const {
  return frame_options_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 WindowClause::frame_options() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.frame_options)
  return _internal_frame_options();
}
inline void WindowClause::_internal_set_frame_options(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  frame_options_ = value;
}
inline void WindowClause::set_frame_options(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_frame_options(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.frame_options)
}

// .pg_query.Node start_offset = 6 [json_name = "startOffset"];
inline bool WindowClause::_internal_has_start_offset() const {
  return this != internal_default_instance() && start_offset_ != nullptr;
}
inline bool WindowClause::has_start_offset() const {
  return _internal_has_start_offset();
}
inline void WindowClause::clear_start_offset() {
  if (GetArena() == nullptr && start_offset_ != nullptr) {
    delete start_offset_;
  }
  start_offset_ = nullptr;
}
inline const ::pg_query::Node& WindowClause::_internal_start_offset() const {
  const ::pg_query::Node* p = start_offset_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& WindowClause::start_offset() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.start_offset)
  return _internal_start_offset();
}
inline void WindowClause::unsafe_arena_set_allocated_start_offset(
    ::pg_query::Node* start_offset) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(start_offset_);
  }
  start_offset_ = start_offset;
  if (start_offset) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowClause.start_offset)
}
inline ::pg_query::Node* WindowClause::release_start_offset() {
  
  ::pg_query::Node* temp = start_offset_;
  start_offset_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* WindowClause::unsafe_arena_release_start_offset() {
  // @@protoc_insertion_point(field_release:pg_query.WindowClause.start_offset)
  
  ::pg_query::Node* temp = start_offset_;
  start_offset_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WindowClause::_internal_mutable_start_offset() {
  
  if (start_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    start_offset_ = p;
  }
  return start_offset_;
}
inline ::pg_query::Node* WindowClause::mutable_start_offset() {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.start_offset)
  return _internal_mutable_start_offset();
}
inline void WindowClause::set_allocated_start_offset(::pg_query::Node* start_offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete start_offset_;
  }
  if (start_offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(start_offset);
    if (message_arena != submessage_arena) {
      start_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, start_offset, submessage_arena);
    }
    
  } else {
    
  }
  start_offset_ = start_offset;
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowClause.start_offset)
}

// .pg_query.Node end_offset = 7 [json_name = "endOffset"];
inline bool WindowClause::_internal_has_end_offset() const {
  return this != internal_default_instance() && end_offset_ != nullptr;
}
inline bool WindowClause::has_end_offset() const {
  return _internal_has_end_offset();
}
inline void WindowClause::clear_end_offset() {
  if (GetArena() == nullptr && end_offset_ != nullptr) {
    delete end_offset_;
  }
  end_offset_ = nullptr;
}
inline const ::pg_query::Node& WindowClause::_internal_end_offset() const {
  const ::pg_query::Node* p = end_offset_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& WindowClause::end_offset() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.end_offset)
  return _internal_end_offset();
}
inline void WindowClause::unsafe_arena_set_allocated_end_offset(
    ::pg_query::Node* end_offset) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(end_offset_);
  }
  end_offset_ = end_offset;
  if (end_offset) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowClause.end_offset)
}
inline ::pg_query::Node* WindowClause::release_end_offset() {
  
  ::pg_query::Node* temp = end_offset_;
  end_offset_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* WindowClause::unsafe_arena_release_end_offset() {
  // @@protoc_insertion_point(field_release:pg_query.WindowClause.end_offset)
  
  ::pg_query::Node* temp = end_offset_;
  end_offset_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WindowClause::_internal_mutable_end_offset() {
  
  if (end_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    end_offset_ = p;
  }
  return end_offset_;
}
inline ::pg_query::Node* WindowClause::mutable_end_offset() {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.end_offset)
  return _internal_mutable_end_offset();
}
inline void WindowClause::set_allocated_end_offset(::pg_query::Node* end_offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete end_offset_;
  }
  if (end_offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(end_offset);
    if (message_arena != submessage_arena) {
      end_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, end_offset, submessage_arena);
    }
    
  } else {
    
  }
  end_offset_ = end_offset;
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowClause.end_offset)
}

// uint32 start_in_range_func = 8 [json_name = "startInRangeFunc"];
inline void WindowClause::clear_start_in_range_func() {
  start_in_range_func_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowClause::_internal_start_in_range_func() const {
  return start_in_range_func_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowClause::start_in_range_func() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.start_in_range_func)
  return _internal_start_in_range_func();
}
inline void WindowClause::_internal_set_start_in_range_func(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  start_in_range_func_ = value;
}
inline void WindowClause::set_start_in_range_func(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_start_in_range_func(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.start_in_range_func)
}

// uint32 end_in_range_func = 9 [json_name = "endInRangeFunc"];
inline void WindowClause::clear_end_in_range_func() {
  end_in_range_func_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowClause::_internal_end_in_range_func() const {
  return end_in_range_func_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowClause::end_in_range_func() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.end_in_range_func)
  return _internal_end_in_range_func();
}
inline void WindowClause::_internal_set_end_in_range_func(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  end_in_range_func_ = value;
}
inline void WindowClause::set_end_in_range_func(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_end_in_range_func(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.end_in_range_func)
}

// uint32 in_range_coll = 10 [json_name = "inRangeColl"];
inline void WindowClause::clear_in_range_coll() {
  in_range_coll_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowClause::_internal_in_range_coll() const {
  return in_range_coll_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowClause::in_range_coll() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.in_range_coll)
  return _internal_in_range_coll();
}
inline void WindowClause::_internal_set_in_range_coll(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  in_range_coll_ = value;
}
inline void WindowClause::set_in_range_coll(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_in_range_coll(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.in_range_coll)
}

// bool in_range_asc = 11 [json_name = "inRangeAsc"];
inline void WindowClause::clear_in_range_asc() {
  in_range_asc_ = false;
}
inline bool WindowClause::_internal_in_range_asc() const {
  return in_range_asc_;
}
inline bool WindowClause::in_range_asc() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.in_range_asc)
  return _internal_in_range_asc();
}
inline void WindowClause::_internal_set_in_range_asc(bool value) {
  
  in_range_asc_ = value;
}
inline void WindowClause::set_in_range_asc(bool value) {
  _internal_set_in_range_asc(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.in_range_asc)
}

// bool in_range_nulls_first = 12 [json_name = "inRangeNullsFirst"];
inline void WindowClause::clear_in_range_nulls_first() {
  in_range_nulls_first_ = false;
}
inline bool WindowClause::_internal_in_range_nulls_first() const {
  return in_range_nulls_first_;
}
inline bool WindowClause::in_range_nulls_first() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.in_range_nulls_first)
  return _internal_in_range_nulls_first();
}
inline void WindowClause::_internal_set_in_range_nulls_first(bool value) {
  
  in_range_nulls_first_ = value;
}
inline void WindowClause::set_in_range_nulls_first(bool value) {
  _internal_set_in_range_nulls_first(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.in_range_nulls_first)
}

// uint32 winref = 13 [json_name = "winref"];
inline void WindowClause::clear_winref() {
  winref_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowClause::_internal_winref() const {
  return winref_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WindowClause::winref() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.winref)
  return _internal_winref();
}
inline void WindowClause::_internal_set_winref(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  winref_ = value;
}
inline void WindowClause::set_winref(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_winref(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.winref)
}

// bool copied_order = 14 [json_name = "copiedOrder"];
inline void WindowClause::clear_copied_order() {
  copied_order_ = false;
}
inline bool WindowClause::_internal_copied_order() const {
  return copied_order_;
}
inline bool WindowClause::copied_order() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.copied_order)
  return _internal_copied_order();
}
inline void WindowClause::_internal_set_copied_order(bool value) {
  
  copied_order_ = value;
}
inline void WindowClause::set_copied_order(bool value) {
  _internal_set_copied_order(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.copied_order)
}

// -------------------------------------------------------------------

// ObjectWithArgs

// repeated .pg_query.Node objname = 1 [json_name = "objname"];
inline int ObjectWithArgs::_internal_objname_size() const {
  return objname_.size();
}
inline int ObjectWithArgs::objname_size() const {
  return _internal_objname_size();
}
inline void ObjectWithArgs::clear_objname() {
  objname_.Clear();
}
inline ::pg_query::Node* ObjectWithArgs::mutable_objname(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ObjectWithArgs.objname)
  return objname_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ObjectWithArgs::mutable_objname() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ObjectWithArgs.objname)
  return &objname_;
}
inline const ::pg_query::Node& ObjectWithArgs::_internal_objname(int index) const {
  return objname_.Get(index);
}
inline const ::pg_query::Node& ObjectWithArgs::objname(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ObjectWithArgs.objname)
  return _internal_objname(index);
}
inline ::pg_query::Node* ObjectWithArgs::_internal_add_objname() {
  return objname_.Add();
}
inline ::pg_query::Node* ObjectWithArgs::add_objname() {
  // @@protoc_insertion_point(field_add:pg_query.ObjectWithArgs.objname)
  return _internal_add_objname();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ObjectWithArgs::objname() const {
  // @@protoc_insertion_point(field_list:pg_query.ObjectWithArgs.objname)
  return objname_;
}

// repeated .pg_query.Node objargs = 2 [json_name = "objargs"];
inline int ObjectWithArgs::_internal_objargs_size() const {
  return objargs_.size();
}
inline int ObjectWithArgs::objargs_size() const {
  return _internal_objargs_size();
}
inline void ObjectWithArgs::clear_objargs() {
  objargs_.Clear();
}
inline ::pg_query::Node* ObjectWithArgs::mutable_objargs(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.ObjectWithArgs.objargs)
  return objargs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
ObjectWithArgs::mutable_objargs() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ObjectWithArgs.objargs)
  return &objargs_;
}
inline const ::pg_query::Node& ObjectWithArgs::_internal_objargs(int index) const {
  return objargs_.Get(index);
}
inline const ::pg_query::Node& ObjectWithArgs::objargs(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.ObjectWithArgs.objargs)
  return _internal_objargs(index);
}
inline ::pg_query::Node* ObjectWithArgs::_internal_add_objargs() {
  return objargs_.Add();
}
inline ::pg_query::Node* ObjectWithArgs::add_objargs() {
  // @@protoc_insertion_point(field_add:pg_query.ObjectWithArgs.objargs)
  return _internal_add_objargs();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
ObjectWithArgs::objargs() const {
  // @@protoc_insertion_point(field_list:pg_query.ObjectWithArgs.objargs)
  return objargs_;
}

// bool args_unspecified = 3 [json_name = "args_unspecified"];
inline void ObjectWithArgs::clear_args_unspecified() {
  args_unspecified_ = false;
}
inline bool ObjectWithArgs::_internal_args_unspecified() const {
  return args_unspecified_;
}
inline bool ObjectWithArgs::args_unspecified() const {
  // @@protoc_insertion_point(field_get:pg_query.ObjectWithArgs.args_unspecified)
  return _internal_args_unspecified();
}
inline void ObjectWithArgs::_internal_set_args_unspecified(bool value) {
  
  args_unspecified_ = value;
}
inline void ObjectWithArgs::set_args_unspecified(bool value) {
  _internal_set_args_unspecified(value);
  // @@protoc_insertion_point(field_set:pg_query.ObjectWithArgs.args_unspecified)
}

// -------------------------------------------------------------------

// AccessPriv

// string priv_name = 1 [json_name = "priv_name"];
inline void AccessPriv::clear_priv_name() {
  priv_name_.ClearToEmpty();
}
inline const std::string& AccessPriv::priv_name() const {
  // @@protoc_insertion_point(field_get:pg_query.AccessPriv.priv_name)
  return _internal_priv_name();
}
inline void AccessPriv::set_priv_name(const std::string& value) {
  _internal_set_priv_name(value);
  // @@protoc_insertion_point(field_set:pg_query.AccessPriv.priv_name)
}
inline std::string* AccessPriv::mutable_priv_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.AccessPriv.priv_name)
  return _internal_mutable_priv_name();
}
inline const std::string& AccessPriv::_internal_priv_name() const {
  return priv_name_.Get();
}
inline void AccessPriv::_internal_set_priv_name(const std::string& value) {
  
  priv_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void AccessPriv::set_priv_name(std::string&& value) {
  
  priv_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.AccessPriv.priv_name)
}
inline void AccessPriv::set_priv_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  priv_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.AccessPriv.priv_name)
}
inline void AccessPriv::set_priv_name(const char* value,
    size_t size) {
  
  priv_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.AccessPriv.priv_name)
}
inline std::string* AccessPriv::_internal_mutable_priv_name() {
  
  return priv_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* AccessPriv::release_priv_name() {
  // @@protoc_insertion_point(field_release:pg_query.AccessPriv.priv_name)
  return priv_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void AccessPriv::set_allocated_priv_name(std::string* priv_name) {
  if (priv_name != nullptr) {
    
  } else {
    
  }
  priv_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), priv_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.AccessPriv.priv_name)
}

// repeated .pg_query.Node cols = 2 [json_name = "cols"];
inline int AccessPriv::_internal_cols_size() const {
  return cols_.size();
}
inline int AccessPriv::cols_size() const {
  return _internal_cols_size();
}
inline void AccessPriv::clear_cols() {
  cols_.Clear();
}
inline ::pg_query::Node* AccessPriv::mutable_cols(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.AccessPriv.cols)
  return cols_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
AccessPriv::mutable_cols() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AccessPriv.cols)
  return &cols_;
}
inline const ::pg_query::Node& AccessPriv::_internal_cols(int index) const {
  return cols_.Get(index);
}
inline const ::pg_query::Node& AccessPriv::cols(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.AccessPriv.cols)
  return _internal_cols(index);
}
inline ::pg_query::Node* AccessPriv::_internal_add_cols() {
  return cols_.Add();
}
inline ::pg_query::Node* AccessPriv::add_cols() {
  // @@protoc_insertion_point(field_add:pg_query.AccessPriv.cols)
  return _internal_add_cols();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
AccessPriv::cols() const {
  // @@protoc_insertion_point(field_list:pg_query.AccessPriv.cols)
  return cols_;
}

// -------------------------------------------------------------------

// CreateOpClassItem

// int32 itemtype = 1 [json_name = "itemtype"];
inline void CreateOpClassItem::clear_itemtype() {
  itemtype_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CreateOpClassItem::_internal_itemtype() const {
  return itemtype_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CreateOpClassItem::itemtype() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.itemtype)
  return _internal_itemtype();
}
inline void CreateOpClassItem::_internal_set_itemtype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  itemtype_ = value;
}
inline void CreateOpClassItem::set_itemtype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_itemtype(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateOpClassItem.itemtype)
}

// .pg_query.ObjectWithArgs name = 2 [json_name = "name"];
inline bool CreateOpClassItem::_internal_has_name() const {
  return this != internal_default_instance() && name_ != nullptr;
}
inline bool CreateOpClassItem::has_name() const {
  return _internal_has_name();
}
inline void CreateOpClassItem::clear_name() {
  if (GetArena() == nullptr && name_ != nullptr) {
    delete name_;
  }
  name_ = nullptr;
}
inline const ::pg_query::ObjectWithArgs& CreateOpClassItem::_internal_name() const {
  const ::pg_query::ObjectWithArgs* p = name_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::ObjectWithArgs&>(
      ::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& CreateOpClassItem::name() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.name)
  return _internal_name();
}
inline void CreateOpClassItem::unsafe_arena_set_allocated_name(
    ::pg_query::ObjectWithArgs* name) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(name_);
  }
  name_ = name;
  if (name) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateOpClassItem.name)
}
inline ::pg_query::ObjectWithArgs* CreateOpClassItem::release_name() {
  
  ::pg_query::ObjectWithArgs* temp = name_;
  name_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::ObjectWithArgs* CreateOpClassItem::unsafe_arena_release_name() {
  // @@protoc_insertion_point(field_release:pg_query.CreateOpClassItem.name)
  
  ::pg_query::ObjectWithArgs* temp = name_;
  name_ = nullptr;
  return temp;
}
inline ::pg_query::ObjectWithArgs* CreateOpClassItem::_internal_mutable_name() {
  
  if (name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArena());
    name_ = p;
  }
  return name_;
}
inline ::pg_query::ObjectWithArgs* CreateOpClassItem::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassItem.name)
  return _internal_mutable_name();
}
inline void CreateOpClassItem::set_allocated_name(::pg_query::ObjectWithArgs* name) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete name_;
  }
  if (name) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(name);
    if (message_arena != submessage_arena) {
      name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, name, submessage_arena);
    }
    
  } else {
    
  }
  name_ = name;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateOpClassItem.name)
}

// int32 number = 3 [json_name = "number"];
inline void CreateOpClassItem::clear_number() {
  number_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CreateOpClassItem::_internal_number() const {
  return number_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CreateOpClassItem::number() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.number)
  return _internal_number();
}
inline void CreateOpClassItem::_internal_set_number(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  number_ = value;
}
inline void CreateOpClassItem::set_number(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_number(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateOpClassItem.number)
}

// repeated .pg_query.Node order_family = 4 [json_name = "order_family"];
inline int CreateOpClassItem::_internal_order_family_size() const {
  return order_family_.size();
}
inline int CreateOpClassItem::order_family_size() const {
  return _internal_order_family_size();
}
inline void CreateOpClassItem::clear_order_family() {
  order_family_.Clear();
}
inline ::pg_query::Node* CreateOpClassItem::mutable_order_family(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassItem.order_family)
  return order_family_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateOpClassItem::mutable_order_family() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassItem.order_family)
  return &order_family_;
}
inline const ::pg_query::Node& CreateOpClassItem::_internal_order_family(int index) const {
  return order_family_.Get(index);
}
inline const ::pg_query::Node& CreateOpClassItem::order_family(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.order_family)
  return _internal_order_family(index);
}
inline ::pg_query::Node* CreateOpClassItem::_internal_add_order_family() {
  return order_family_.Add();
}
inline ::pg_query::Node* CreateOpClassItem::add_order_family() {
  // @@protoc_insertion_point(field_add:pg_query.CreateOpClassItem.order_family)
  return _internal_add_order_family();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateOpClassItem::order_family() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateOpClassItem.order_family)
  return order_family_;
}

// repeated .pg_query.Node class_args = 5 [json_name = "class_args"];
inline int CreateOpClassItem::_internal_class_args_size() const {
  return class_args_.size();
}
inline int CreateOpClassItem::class_args_size() const {
  return _internal_class_args_size();
}
inline void CreateOpClassItem::clear_class_args() {
  class_args_.Clear();
}
inline ::pg_query::Node* CreateOpClassItem::mutable_class_args(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassItem.class_args)
  return class_args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CreateOpClassItem::mutable_class_args() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassItem.class_args)
  return &class_args_;
}
inline const ::pg_query::Node& CreateOpClassItem::_internal_class_args(int index) const {
  return class_args_.Get(index);
}
inline const ::pg_query::Node& CreateOpClassItem::class_args(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.class_args)
  return _internal_class_args(index);
}
inline ::pg_query::Node* CreateOpClassItem::_internal_add_class_args() {
  return class_args_.Add();
}
inline ::pg_query::Node* CreateOpClassItem::add_class_args() {
  // @@protoc_insertion_point(field_add:pg_query.CreateOpClassItem.class_args)
  return _internal_add_class_args();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CreateOpClassItem::class_args() const {
  // @@protoc_insertion_point(field_list:pg_query.CreateOpClassItem.class_args)
  return class_args_;
}

// .pg_query.TypeName storedtype = 6 [json_name = "storedtype"];
inline bool CreateOpClassItem::_internal_has_storedtype() const {
  return this != internal_default_instance() && storedtype_ != nullptr;
}
inline bool CreateOpClassItem::has_storedtype() const {
  return _internal_has_storedtype();
}
inline void CreateOpClassItem::clear_storedtype() {
  if (GetArena() == nullptr && storedtype_ != nullptr) {
    delete storedtype_;
  }
  storedtype_ = nullptr;
}
inline const ::pg_query::TypeName& CreateOpClassItem::_internal_storedtype() const {
  const ::pg_query::TypeName* p = storedtype_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(
      ::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& CreateOpClassItem::storedtype() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.storedtype)
  return _internal_storedtype();
}
inline void CreateOpClassItem::unsafe_arena_set_allocated_storedtype(
    ::pg_query::TypeName* storedtype) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(storedtype_);
  }
  storedtype_ = storedtype;
  if (storedtype) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateOpClassItem.storedtype)
}
inline ::pg_query::TypeName* CreateOpClassItem::release_storedtype() {
  
  ::pg_query::TypeName* temp = storedtype_;
  storedtype_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TypeName* CreateOpClassItem::unsafe_arena_release_storedtype() {
  // @@protoc_insertion_point(field_release:pg_query.CreateOpClassItem.storedtype)
  
  ::pg_query::TypeName* temp = storedtype_;
  storedtype_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateOpClassItem::_internal_mutable_storedtype() {
  
  if (storedtype_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    storedtype_ = p;
  }
  return storedtype_;
}
inline ::pg_query::TypeName* CreateOpClassItem::mutable_storedtype() {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassItem.storedtype)
  return _internal_mutable_storedtype();
}
inline void CreateOpClassItem::set_allocated_storedtype(::pg_query::TypeName* storedtype) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete storedtype_;
  }
  if (storedtype) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(storedtype);
    if (message_arena != submessage_arena) {
      storedtype = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, storedtype, submessage_arena);
    }
    
  } else {
    
  }
  storedtype_ = storedtype;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateOpClassItem.storedtype)
}

// -------------------------------------------------------------------

// TableLikeClause

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool TableLikeClause::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool TableLikeClause::has_relation() const {
  return _internal_has_relation();
}
inline void TableLikeClause::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& TableLikeClause::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& TableLikeClause::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.TableLikeClause.relation)
  return _internal_relation();
}
inline void TableLikeClause::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TableLikeClause.relation)
}
inline ::pg_query::RangeVar* TableLikeClause::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* TableLikeClause::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.TableLikeClause.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* TableLikeClause::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* TableLikeClause::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.TableLikeClause.relation)
  return _internal_mutable_relation();
}
inline void TableLikeClause::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.TableLikeClause.relation)
}

// uint32 options = 2 [json_name = "options"];
inline void TableLikeClause::clear_options() {
  options_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TableLikeClause::_internal_options() const {
  return options_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TableLikeClause::options() const {
  // @@protoc_insertion_point(field_get:pg_query.TableLikeClause.options)
  return _internal_options();
}
inline void TableLikeClause::_internal_set_options(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  options_ = value;
}
inline void TableLikeClause::set_options(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_options(value);
  // @@protoc_insertion_point(field_set:pg_query.TableLikeClause.options)
}

// -------------------------------------------------------------------

// FunctionParameter

// string name = 1 [json_name = "name"];
inline void FunctionParameter::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& FunctionParameter::name() const {
  // @@protoc_insertion_point(field_get:pg_query.FunctionParameter.name)
  return _internal_name();
}
inline void FunctionParameter::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.FunctionParameter.name)
}
inline std::string* FunctionParameter::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.FunctionParameter.name)
  return _internal_mutable_name();
}
inline const std::string& FunctionParameter::_internal_name() const {
  return name_.Get();
}
inline void FunctionParameter::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FunctionParameter::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.FunctionParameter.name)
}
inline void FunctionParameter::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.FunctionParameter.name)
}
inline void FunctionParameter::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.FunctionParameter.name)
}
inline std::string* FunctionParameter::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FunctionParameter::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.FunctionParameter.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FunctionParameter::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.FunctionParameter.name)
}

// .pg_query.TypeName arg_type = 2 [json_name = "argType"];
inline bool FunctionParameter::_internal_has_arg_type() const {
  return this != internal_default_instance() && arg_type_ != nullptr;
}
inline bool FunctionParameter::has_arg_type() const {
  return _internal_has_arg_type();
}
inline void FunctionParameter::clear_arg_type() {
  if (GetArena() == nullptr && arg_type_ != nullptr) {
    delete arg_type_;
  }
  arg_type_ = nullptr;
}
inline const ::pg_query::TypeName& FunctionParameter::_internal_arg_type() const {
  const ::pg_query::TypeName* p = arg_type_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(
      ::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& FunctionParameter::arg_type() const {
  // @@protoc_insertion_point(field_get:pg_query.FunctionParameter.arg_type)
  return _internal_arg_type();
}
inline void FunctionParameter::unsafe_arena_set_allocated_arg_type(
    ::pg_query::TypeName* arg_type) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_type_);
  }
  arg_type_ = arg_type;
  if (arg_type) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FunctionParameter.arg_type)
}
inline ::pg_query::TypeName* FunctionParameter::release_arg_type() {
  
  ::pg_query::TypeName* temp = arg_type_;
  arg_type_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TypeName* FunctionParameter::unsafe_arena_release_arg_type() {
  // @@protoc_insertion_point(field_release:pg_query.FunctionParameter.arg_type)
  
  ::pg_query::TypeName* temp = arg_type_;
  arg_type_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* FunctionParameter::_internal_mutable_arg_type() {
  
  if (arg_type_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    arg_type_ = p;
  }
  return arg_type_;
}
inline ::pg_query::TypeName* FunctionParameter::mutable_arg_type() {
  // @@protoc_insertion_point(field_mutable:pg_query.FunctionParameter.arg_type)
  return _internal_mutable_arg_type();
}
inline void FunctionParameter::set_allocated_arg_type(::pg_query::TypeName* arg_type) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arg_type_;
  }
  if (arg_type) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg_type);
    if (message_arena != submessage_arena) {
      arg_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg_type, submessage_arena);
    }
    
  } else {
    
  }
  arg_type_ = arg_type;
  // @@protoc_insertion_point(field_set_allocated:pg_query.FunctionParameter.arg_type)
}

// .pg_query.FunctionParameterMode mode = 3 [json_name = "mode"];
inline void FunctionParameter::clear_mode() {
  mode_ = 0;
}
inline ::pg_query::FunctionParameterMode FunctionParameter::_internal_mode() const {
  return static_cast< ::pg_query::FunctionParameterMode >(mode_);
}
inline ::pg_query::FunctionParameterMode FunctionParameter::mode() const {
  // @@protoc_insertion_point(field_get:pg_query.FunctionParameter.mode)
  return _internal_mode();
}
inline void FunctionParameter::_internal_set_mode(::pg_query::FunctionParameterMode value) {
  
  mode_ = value;
}
inline void FunctionParameter::set_mode(::pg_query::FunctionParameterMode value) {
  _internal_set_mode(value);
  // @@protoc_insertion_point(field_set:pg_query.FunctionParameter.mode)
}

// .pg_query.Node defexpr = 4 [json_name = "defexpr"];
inline bool FunctionParameter::_internal_has_defexpr() const {
  return this != internal_default_instance() && defexpr_ != nullptr;
}
inline bool FunctionParameter::has_defexpr() const {
  return _internal_has_defexpr();
}
inline void FunctionParameter::clear_defexpr() {
  if (GetArena() == nullptr && defexpr_ != nullptr) {
    delete defexpr_;
  }
  defexpr_ = nullptr;
}
inline const ::pg_query::Node& FunctionParameter::_internal_defexpr() const {
  const ::pg_query::Node* p = defexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FunctionParameter::defexpr() const {
  // @@protoc_insertion_point(field_get:pg_query.FunctionParameter.defexpr)
  return _internal_defexpr();
}
inline void FunctionParameter::unsafe_arena_set_allocated_defexpr(
    ::pg_query::Node* defexpr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(defexpr_);
  }
  defexpr_ = defexpr;
  if (defexpr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FunctionParameter.defexpr)
}
inline ::pg_query::Node* FunctionParameter::release_defexpr() {
  
  ::pg_query::Node* temp = defexpr_;
  defexpr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* FunctionParameter::unsafe_arena_release_defexpr() {
  // @@protoc_insertion_point(field_release:pg_query.FunctionParameter.defexpr)
  
  ::pg_query::Node* temp = defexpr_;
  defexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FunctionParameter::_internal_mutable_defexpr() {
  
  if (defexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    defexpr_ = p;
  }
  return defexpr_;
}
inline ::pg_query::Node* FunctionParameter::mutable_defexpr() {
  // @@protoc_insertion_point(field_mutable:pg_query.FunctionParameter.defexpr)
  return _internal_mutable_defexpr();
}
inline void FunctionParameter::set_allocated_defexpr(::pg_query::Node* defexpr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete defexpr_;
  }
  if (defexpr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(defexpr);
    if (message_arena != submessage_arena) {
      defexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, defexpr, submessage_arena);
    }
    
  } else {
    
  }
  defexpr_ = defexpr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.FunctionParameter.defexpr)
}

// -------------------------------------------------------------------

// LockingClause

// repeated .pg_query.Node locked_rels = 1 [json_name = "lockedRels"];
inline int LockingClause::_internal_locked_rels_size() const {
  return locked_rels_.size();
}
inline int LockingClause::locked_rels_size() const {
  return _internal_locked_rels_size();
}
inline void LockingClause::clear_locked_rels() {
  locked_rels_.Clear();
}
inline ::pg_query::Node* LockingClause::mutable_locked_rels(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.LockingClause.locked_rels)
  return locked_rels_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
LockingClause::mutable_locked_rels() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.LockingClause.locked_rels)
  return &locked_rels_;
}
inline const ::pg_query::Node& LockingClause::_internal_locked_rels(int index) const {
  return locked_rels_.Get(index);
}
inline const ::pg_query::Node& LockingClause::locked_rels(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.LockingClause.locked_rels)
  return _internal_locked_rels(index);
}
inline ::pg_query::Node* LockingClause::_internal_add_locked_rels() {
  return locked_rels_.Add();
}
inline ::pg_query::Node* LockingClause::add_locked_rels() {
  // @@protoc_insertion_point(field_add:pg_query.LockingClause.locked_rels)
  return _internal_add_locked_rels();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
LockingClause::locked_rels() const {
  // @@protoc_insertion_point(field_list:pg_query.LockingClause.locked_rels)
  return locked_rels_;
}

// .pg_query.LockClauseStrength strength = 2 [json_name = "strength"];
inline void LockingClause::clear_strength() {
  strength_ = 0;
}
inline ::pg_query::LockClauseStrength LockingClause::_internal_strength() const {
  return static_cast< ::pg_query::LockClauseStrength >(strength_);
}
inline ::pg_query::LockClauseStrength LockingClause::strength() const {
  // @@protoc_insertion_point(field_get:pg_query.LockingClause.strength)
  return _internal_strength();
}
inline void LockingClause::_internal_set_strength(::pg_query::LockClauseStrength value) {
  
  strength_ = value;
}
inline void LockingClause::set_strength(::pg_query::LockClauseStrength value) {
  _internal_set_strength(value);
  // @@protoc_insertion_point(field_set:pg_query.LockingClause.strength)
}

// .pg_query.LockWaitPolicy wait_policy = 3 [json_name = "waitPolicy"];
inline void LockingClause::clear_wait_policy() {
  wait_policy_ = 0;
}
inline ::pg_query::LockWaitPolicy LockingClause::_internal_wait_policy() const {
  return static_cast< ::pg_query::LockWaitPolicy >(wait_policy_);
}
inline ::pg_query::LockWaitPolicy LockingClause::wait_policy() const {
  // @@protoc_insertion_point(field_get:pg_query.LockingClause.wait_policy)
  return _internal_wait_policy();
}
inline void LockingClause::_internal_set_wait_policy(::pg_query::LockWaitPolicy value) {
  
  wait_policy_ = value;
}
inline void LockingClause::set_wait_policy(::pg_query::LockWaitPolicy value) {
  _internal_set_wait_policy(value);
  // @@protoc_insertion_point(field_set:pg_query.LockingClause.wait_policy)
}

// -------------------------------------------------------------------

// RowMarkClause

// uint32 rti = 1 [json_name = "rti"];
inline void RowMarkClause::clear_rti() {
  rti_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RowMarkClause::_internal_rti() const {
  return rti_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 RowMarkClause::rti() const {
  // @@protoc_insertion_point(field_get:pg_query.RowMarkClause.rti)
  return _internal_rti();
}
inline void RowMarkClause::_internal_set_rti(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  rti_ = value;
}
inline void RowMarkClause::set_rti(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_rti(value);
  // @@protoc_insertion_point(field_set:pg_query.RowMarkClause.rti)
}

// .pg_query.LockClauseStrength strength = 2 [json_name = "strength"];
inline void RowMarkClause::clear_strength() {
  strength_ = 0;
}
inline ::pg_query::LockClauseStrength RowMarkClause::_internal_strength() const {
  return static_cast< ::pg_query::LockClauseStrength >(strength_);
}
inline ::pg_query::LockClauseStrength RowMarkClause::strength() const {
  // @@protoc_insertion_point(field_get:pg_query.RowMarkClause.strength)
  return _internal_strength();
}
inline void RowMarkClause::_internal_set_strength(::pg_query::LockClauseStrength value) {
  
  strength_ = value;
}
inline void RowMarkClause::set_strength(::pg_query::LockClauseStrength value) {
  _internal_set_strength(value);
  // @@protoc_insertion_point(field_set:pg_query.RowMarkClause.strength)
}

// .pg_query.LockWaitPolicy wait_policy = 3 [json_name = "waitPolicy"];
inline void RowMarkClause::clear_wait_policy() {
  wait_policy_ = 0;
}
inline ::pg_query::LockWaitPolicy RowMarkClause::_internal_wait_policy() const {
  return static_cast< ::pg_query::LockWaitPolicy >(wait_policy_);
}
inline ::pg_query::LockWaitPolicy RowMarkClause::wait_policy() const {
  // @@protoc_insertion_point(field_get:pg_query.RowMarkClause.wait_policy)
  return _internal_wait_policy();
}
inline void RowMarkClause::_internal_set_wait_policy(::pg_query::LockWaitPolicy value) {
  
  wait_policy_ = value;
}
inline void RowMarkClause::set_wait_policy(::pg_query::LockWaitPolicy value) {
  _internal_set_wait_policy(value);
  // @@protoc_insertion_point(field_set:pg_query.RowMarkClause.wait_policy)
}

// bool pushed_down = 4 [json_name = "pushedDown"];
inline void RowMarkClause::clear_pushed_down() {
  pushed_down_ = false;
}
inline bool RowMarkClause::_internal_pushed_down() const {
  return pushed_down_;
}
inline bool RowMarkClause::pushed_down() const {
  // @@protoc_insertion_point(field_get:pg_query.RowMarkClause.pushed_down)
  return _internal_pushed_down();
}
inline void RowMarkClause::_internal_set_pushed_down(bool value) {
  
  pushed_down_ = value;
}
inline void RowMarkClause::set_pushed_down(bool value) {
  _internal_set_pushed_down(value);
  // @@protoc_insertion_point(field_set:pg_query.RowMarkClause.pushed_down)
}

// -------------------------------------------------------------------

// XmlSerialize

// .pg_query.XmlOptionType xmloption = 1 [json_name = "xmloption"];
inline void XmlSerialize::clear_xmloption() {
  xmloption_ = 0;
}
inline ::pg_query::XmlOptionType XmlSerialize::_internal_xmloption() const {
  return static_cast< ::pg_query::XmlOptionType >(xmloption_);
}
inline ::pg_query::XmlOptionType XmlSerialize::xmloption() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlSerialize.xmloption)
  return _internal_xmloption();
}
inline void XmlSerialize::_internal_set_xmloption(::pg_query::XmlOptionType value) {
  
  xmloption_ = value;
}
inline void XmlSerialize::set_xmloption(::pg_query::XmlOptionType value) {
  _internal_set_xmloption(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlSerialize.xmloption)
}

// .pg_query.Node expr = 2 [json_name = "expr"];
inline bool XmlSerialize::_internal_has_expr() const {
  return this != internal_default_instance() && expr_ != nullptr;
}
inline bool XmlSerialize::has_expr() const {
  return _internal_has_expr();
}
inline void XmlSerialize::clear_expr() {
  if (GetArena() == nullptr && expr_ != nullptr) {
    delete expr_;
  }
  expr_ = nullptr;
}
inline const ::pg_query::Node& XmlSerialize::_internal_expr() const {
  const ::pg_query::Node* p = expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& XmlSerialize::expr() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlSerialize.expr)
  return _internal_expr();
}
inline void XmlSerialize::unsafe_arena_set_allocated_expr(
    ::pg_query::Node* expr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expr_);
  }
  expr_ = expr;
  if (expr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.XmlSerialize.expr)
}
inline ::pg_query::Node* XmlSerialize::release_expr() {
  
  ::pg_query::Node* temp = expr_;
  expr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* XmlSerialize::unsafe_arena_release_expr() {
  // @@protoc_insertion_point(field_release:pg_query.XmlSerialize.expr)
  
  ::pg_query::Node* temp = expr_;
  expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* XmlSerialize::_internal_mutable_expr() {
  
  if (expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    expr_ = p;
  }
  return expr_;
}
inline ::pg_query::Node* XmlSerialize::mutable_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.XmlSerialize.expr)
  return _internal_mutable_expr();
}
inline void XmlSerialize::set_allocated_expr(::pg_query::Node* expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete expr_;
  }
  if (expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expr);
    if (message_arena != submessage_arena) {
      expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, expr, submessage_arena);
    }
    
  } else {
    
  }
  expr_ = expr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.XmlSerialize.expr)
}

// .pg_query.TypeName type_name = 3 [json_name = "typeName"];
inline bool XmlSerialize::_internal_has_type_name() const {
  return this != internal_default_instance() && type_name_ != nullptr;
}
inline bool XmlSerialize::has_type_name() const {
  return _internal_has_type_name();
}
inline void XmlSerialize::clear_type_name() {
  if (GetArena() == nullptr && type_name_ != nullptr) {
    delete type_name_;
  }
  type_name_ = nullptr;
}
inline const ::pg_query::TypeName& XmlSerialize::_internal_type_name() const {
  const ::pg_query::TypeName* p = type_name_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(
      ::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& XmlSerialize::type_name() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlSerialize.type_name)
  return _internal_type_name();
}
inline void XmlSerialize::unsafe_arena_set_allocated_type_name(
    ::pg_query::TypeName* type_name) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_name_);
  }
  type_name_ = type_name;
  if (type_name) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.XmlSerialize.type_name)
}
inline ::pg_query::TypeName* XmlSerialize::release_type_name() {
  
  ::pg_query::TypeName* temp = type_name_;
  type_name_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::TypeName* XmlSerialize::unsafe_arena_release_type_name() {
  // @@protoc_insertion_point(field_release:pg_query.XmlSerialize.type_name)
  
  ::pg_query::TypeName* temp = type_name_;
  type_name_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* XmlSerialize::_internal_mutable_type_name() {
  
  if (type_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    type_name_ = p;
  }
  return type_name_;
}
inline ::pg_query::TypeName* XmlSerialize::mutable_type_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.XmlSerialize.type_name)
  return _internal_mutable_type_name();
}
inline void XmlSerialize::set_allocated_type_name(::pg_query::TypeName* type_name) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete type_name_;
  }
  if (type_name) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_name);
    if (message_arena != submessage_arena) {
      type_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, type_name, submessage_arena);
    }
    
  } else {
    
  }
  type_name_ = type_name;
  // @@protoc_insertion_point(field_set_allocated:pg_query.XmlSerialize.type_name)
}

// int32 location = 4 [json_name = "location"];
inline void XmlSerialize::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 XmlSerialize::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 XmlSerialize::location() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlSerialize.location)
  return _internal_location();
}
inline void XmlSerialize::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void XmlSerialize::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlSerialize.location)
}

// -------------------------------------------------------------------

// WithClause

// repeated .pg_query.Node ctes = 1 [json_name = "ctes"];
inline int WithClause::_internal_ctes_size() const {
  return ctes_.size();
}
inline int WithClause::ctes_size() const {
  return _internal_ctes_size();
}
inline void WithClause::clear_ctes() {
  ctes_.Clear();
}
inline ::pg_query::Node* WithClause::mutable_ctes(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.WithClause.ctes)
  return ctes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
WithClause::mutable_ctes() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.WithClause.ctes)
  return &ctes_;
}
inline const ::pg_query::Node& WithClause::_internal_ctes(int index) const {
  return ctes_.Get(index);
}
inline const ::pg_query::Node& WithClause::ctes(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.WithClause.ctes)
  return _internal_ctes(index);
}
inline ::pg_query::Node* WithClause::_internal_add_ctes() {
  return ctes_.Add();
}
inline ::pg_query::Node* WithClause::add_ctes() {
  // @@protoc_insertion_point(field_add:pg_query.WithClause.ctes)
  return _internal_add_ctes();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
WithClause::ctes() const {
  // @@protoc_insertion_point(field_list:pg_query.WithClause.ctes)
  return ctes_;
}

// bool recursive = 2 [json_name = "recursive"];
inline void WithClause::clear_recursive() {
  recursive_ = false;
}
inline bool WithClause::_internal_recursive() const {
  return recursive_;
}
inline bool WithClause::recursive() const {
  // @@protoc_insertion_point(field_get:pg_query.WithClause.recursive)
  return _internal_recursive();
}
inline void WithClause::_internal_set_recursive(bool value) {
  
  recursive_ = value;
}
inline void WithClause::set_recursive(bool value) {
  _internal_set_recursive(value);
  // @@protoc_insertion_point(field_set:pg_query.WithClause.recursive)
}

// int32 location = 3 [json_name = "location"];
inline void WithClause::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 WithClause::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 WithClause::location() const {
  // @@protoc_insertion_point(field_get:pg_query.WithClause.location)
  return _internal_location();
}
inline void WithClause::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void WithClause::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.WithClause.location)
}

// -------------------------------------------------------------------

// InferClause

// repeated .pg_query.Node index_elems = 1 [json_name = "indexElems"];
inline int InferClause::_internal_index_elems_size() const {
  return index_elems_.size();
}
inline int InferClause::index_elems_size() const {
  return _internal_index_elems_size();
}
inline void InferClause::clear_index_elems() {
  index_elems_.Clear();
}
inline ::pg_query::Node* InferClause::mutable_index_elems(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.InferClause.index_elems)
  return index_elems_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
InferClause::mutable_index_elems() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.InferClause.index_elems)
  return &index_elems_;
}
inline const ::pg_query::Node& InferClause::_internal_index_elems(int index) const {
  return index_elems_.Get(index);
}
inline const ::pg_query::Node& InferClause::index_elems(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.InferClause.index_elems)
  return _internal_index_elems(index);
}
inline ::pg_query::Node* InferClause::_internal_add_index_elems() {
  return index_elems_.Add();
}
inline ::pg_query::Node* InferClause::add_index_elems() {
  // @@protoc_insertion_point(field_add:pg_query.InferClause.index_elems)
  return _internal_add_index_elems();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
InferClause::index_elems() const {
  // @@protoc_insertion_point(field_list:pg_query.InferClause.index_elems)
  return index_elems_;
}

// .pg_query.Node where_clause = 2 [json_name = "whereClause"];
inline bool InferClause::_internal_has_where_clause() const {
  return this != internal_default_instance() && where_clause_ != nullptr;
}
inline bool InferClause::has_where_clause() const {
  return _internal_has_where_clause();
}
inline void InferClause::clear_where_clause() {
  if (GetArena() == nullptr && where_clause_ != nullptr) {
    delete where_clause_;
  }
  where_clause_ = nullptr;
}
inline const ::pg_query::Node& InferClause::_internal_where_clause() const {
  const ::pg_query::Node* p = where_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& InferClause::where_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.InferClause.where_clause)
  return _internal_where_clause();
}
inline void InferClause::unsafe_arena_set_allocated_where_clause(
    ::pg_query::Node* where_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(where_clause_);
  }
  where_clause_ = where_clause;
  if (where_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InferClause.where_clause)
}
inline ::pg_query::Node* InferClause::release_where_clause() {
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* InferClause::unsafe_arena_release_where_clause() {
  // @@protoc_insertion_point(field_release:pg_query.InferClause.where_clause)
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* InferClause::_internal_mutable_where_clause() {
  
  if (where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    where_clause_ = p;
  }
  return where_clause_;
}
inline ::pg_query::Node* InferClause::mutable_where_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.InferClause.where_clause)
  return _internal_mutable_where_clause();
}
inline void InferClause::set_allocated_where_clause(::pg_query::Node* where_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete where_clause_;
  }
  if (where_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(where_clause);
    if (message_arena != submessage_arena) {
      where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, where_clause, submessage_arena);
    }
    
  } else {
    
  }
  where_clause_ = where_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.InferClause.where_clause)
}

// string conname = 3 [json_name = "conname"];
inline void InferClause::clear_conname() {
  conname_.ClearToEmpty();
}
inline const std::string& InferClause::conname() const {
  // @@protoc_insertion_point(field_get:pg_query.InferClause.conname)
  return _internal_conname();
}
inline void InferClause::set_conname(const std::string& value) {
  _internal_set_conname(value);
  // @@protoc_insertion_point(field_set:pg_query.InferClause.conname)
}
inline std::string* InferClause::mutable_conname() {
  // @@protoc_insertion_point(field_mutable:pg_query.InferClause.conname)
  return _internal_mutable_conname();
}
inline const std::string& InferClause::_internal_conname() const {
  return conname_.Get();
}
inline void InferClause::_internal_set_conname(const std::string& value) {
  
  conname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void InferClause::set_conname(std::string&& value) {
  
  conname_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.InferClause.conname)
}
inline void InferClause::set_conname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  conname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.InferClause.conname)
}
inline void InferClause::set_conname(const char* value,
    size_t size) {
  
  conname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.InferClause.conname)
}
inline std::string* InferClause::_internal_mutable_conname() {
  
  return conname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* InferClause::release_conname() {
  // @@protoc_insertion_point(field_release:pg_query.InferClause.conname)
  return conname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void InferClause::set_allocated_conname(std::string* conname) {
  if (conname != nullptr) {
    
  } else {
    
  }
  conname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), conname,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.InferClause.conname)
}

// int32 location = 4 [json_name = "location"];
inline void InferClause::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 InferClause::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 InferClause::location() const {
  // @@protoc_insertion_point(field_get:pg_query.InferClause.location)
  return _internal_location();
}
inline void InferClause::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void InferClause::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.InferClause.location)
}

// -------------------------------------------------------------------

// OnConflictClause

// .pg_query.OnConflictAction action = 1 [json_name = "action"];
inline void OnConflictClause::clear_action() {
  action_ = 0;
}
inline ::pg_query::OnConflictAction OnConflictClause::_internal_action() const {
  return static_cast< ::pg_query::OnConflictAction >(action_);
}
inline ::pg_query::OnConflictAction OnConflictClause::action() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.action)
  return _internal_action();
}
inline void OnConflictClause::_internal_set_action(::pg_query::OnConflictAction value) {
  
  action_ = value;
}
inline void OnConflictClause::set_action(::pg_query::OnConflictAction value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:pg_query.OnConflictClause.action)
}

// .pg_query.InferClause infer = 2 [json_name = "infer"];
inline bool OnConflictClause::_internal_has_infer() const {
  return this != internal_default_instance() && infer_ != nullptr;
}
inline bool OnConflictClause::has_infer() const {
  return _internal_has_infer();
}
inline void OnConflictClause::clear_infer() {
  if (GetArena() == nullptr && infer_ != nullptr) {
    delete infer_;
  }
  infer_ = nullptr;
}
inline const ::pg_query::InferClause& OnConflictClause::_internal_infer() const {
  const ::pg_query::InferClause* p = infer_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::InferClause&>(
      ::pg_query::_InferClause_default_instance_);
}
inline const ::pg_query::InferClause& OnConflictClause::infer() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.infer)
  return _internal_infer();
}
inline void OnConflictClause::unsafe_arena_set_allocated_infer(
    ::pg_query::InferClause* infer) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(infer_);
  }
  infer_ = infer;
  if (infer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OnConflictClause.infer)
}
inline ::pg_query::InferClause* OnConflictClause::release_infer() {
  
  ::pg_query::InferClause* temp = infer_;
  infer_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::InferClause* OnConflictClause::unsafe_arena_release_infer() {
  // @@protoc_insertion_point(field_release:pg_query.OnConflictClause.infer)
  
  ::pg_query::InferClause* temp = infer_;
  infer_ = nullptr;
  return temp;
}
inline ::pg_query::InferClause* OnConflictClause::_internal_mutable_infer() {
  
  if (infer_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::InferClause>(GetArena());
    infer_ = p;
  }
  return infer_;
}
inline ::pg_query::InferClause* OnConflictClause::mutable_infer() {
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictClause.infer)
  return _internal_mutable_infer();
}
inline void OnConflictClause::set_allocated_infer(::pg_query::InferClause* infer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete infer_;
  }
  if (infer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(infer);
    if (message_arena != submessage_arena) {
      infer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, infer, submessage_arena);
    }
    
  } else {
    
  }
  infer_ = infer;
  // @@protoc_insertion_point(field_set_allocated:pg_query.OnConflictClause.infer)
}

// repeated .pg_query.Node target_list = 3 [json_name = "targetList"];
inline int OnConflictClause::_internal_target_list_size() const {
  return target_list_.size();
}
inline int OnConflictClause::target_list_size() const {
  return _internal_target_list_size();
}
inline void OnConflictClause::clear_target_list() {
  target_list_.Clear();
}
inline ::pg_query::Node* OnConflictClause::mutable_target_list(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictClause.target_list)
  return target_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
OnConflictClause::mutable_target_list() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.OnConflictClause.target_list)
  return &target_list_;
}
inline const ::pg_query::Node& OnConflictClause::_internal_target_list(int index) const {
  return target_list_.Get(index);
}
inline const ::pg_query::Node& OnConflictClause::target_list(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.target_list)
  return _internal_target_list(index);
}
inline ::pg_query::Node* OnConflictClause::_internal_add_target_list() {
  return target_list_.Add();
}
inline ::pg_query::Node* OnConflictClause::add_target_list() {
  // @@protoc_insertion_point(field_add:pg_query.OnConflictClause.target_list)
  return _internal_add_target_list();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
OnConflictClause::target_list() const {
  // @@protoc_insertion_point(field_list:pg_query.OnConflictClause.target_list)
  return target_list_;
}

// .pg_query.Node where_clause = 4 [json_name = "whereClause"];
inline bool OnConflictClause::_internal_has_where_clause() const {
  return this != internal_default_instance() && where_clause_ != nullptr;
}
inline bool OnConflictClause::has_where_clause() const {
  return _internal_has_where_clause();
}
inline void OnConflictClause::clear_where_clause() {
  if (GetArena() == nullptr && where_clause_ != nullptr) {
    delete where_clause_;
  }
  where_clause_ = nullptr;
}
inline const ::pg_query::Node& OnConflictClause::_internal_where_clause() const {
  const ::pg_query::Node* p = where_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& OnConflictClause::where_clause() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.where_clause)
  return _internal_where_clause();
}
inline void OnConflictClause::unsafe_arena_set_allocated_where_clause(
    ::pg_query::Node* where_clause) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(where_clause_);
  }
  where_clause_ = where_clause;
  if (where_clause) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OnConflictClause.where_clause)
}
inline ::pg_query::Node* OnConflictClause::release_where_clause() {
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* OnConflictClause::unsafe_arena_release_where_clause() {
  // @@protoc_insertion_point(field_release:pg_query.OnConflictClause.where_clause)
  
  ::pg_query::Node* temp = where_clause_;
  where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* OnConflictClause::_internal_mutable_where_clause() {
  
  if (where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    where_clause_ = p;
  }
  return where_clause_;
}
inline ::pg_query::Node* OnConflictClause::mutable_where_clause() {
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictClause.where_clause)
  return _internal_mutable_where_clause();
}
inline void OnConflictClause::set_allocated_where_clause(::pg_query::Node* where_clause) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete where_clause_;
  }
  if (where_clause) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(where_clause);
    if (message_arena != submessage_arena) {
      where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, where_clause, submessage_arena);
    }
    
  } else {
    
  }
  where_clause_ = where_clause;
  // @@protoc_insertion_point(field_set_allocated:pg_query.OnConflictClause.where_clause)
}

// int32 location = 5 [json_name = "location"];
inline void OnConflictClause::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 OnConflictClause::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 OnConflictClause::location() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.location)
  return _internal_location();
}
inline void OnConflictClause::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void OnConflictClause::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.OnConflictClause.location)
}

// -------------------------------------------------------------------

// CommonTableExpr

// string ctename = 1 [json_name = "ctename"];
inline void CommonTableExpr::clear_ctename() {
  ctename_.ClearToEmpty();
}
inline const std::string& CommonTableExpr::ctename() const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctename)
  return _internal_ctename();
}
inline void CommonTableExpr::set_ctename(const std::string& value) {
  _internal_set_ctename(value);
  // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.ctename)
}
inline std::string* CommonTableExpr::mutable_ctename() {
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctename)
  return _internal_mutable_ctename();
}
inline const std::string& CommonTableExpr::_internal_ctename() const {
  return ctename_.Get();
}
inline void CommonTableExpr::_internal_set_ctename(const std::string& value) {
  
  ctename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CommonTableExpr::set_ctename(std::string&& value) {
  
  ctename_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.CommonTableExpr.ctename)
}
inline void CommonTableExpr::set_ctename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  ctename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.CommonTableExpr.ctename)
}
inline void CommonTableExpr::set_ctename(const char* value,
    size_t size) {
  
  ctename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.CommonTableExpr.ctename)
}
inline std::string* CommonTableExpr::_internal_mutable_ctename() {
  
  return ctename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CommonTableExpr::release_ctename() {
  // @@protoc_insertion_point(field_release:pg_query.CommonTableExpr.ctename)
  return ctename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CommonTableExpr::set_allocated_ctename(std::string* ctename) {
  if (ctename != nullptr) {
    
  } else {
    
  }
  ctename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ctename,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.CommonTableExpr.ctename)
}

// repeated .pg_query.Node aliascolnames = 2 [json_name = "aliascolnames"];
inline int CommonTableExpr::_internal_aliascolnames_size() const {
  return aliascolnames_.size();
}
inline int CommonTableExpr::aliascolnames_size() const {
  return _internal_aliascolnames_size();
}
inline void CommonTableExpr::clear_aliascolnames() {
  aliascolnames_.Clear();
}
inline ::pg_query::Node* CommonTableExpr::mutable_aliascolnames(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.aliascolnames)
  return aliascolnames_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CommonTableExpr::mutable_aliascolnames() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.aliascolnames)
  return &aliascolnames_;
}
inline const ::pg_query::Node& CommonTableExpr::_internal_aliascolnames(int index) const {
  return aliascolnames_.Get(index);
}
inline const ::pg_query::Node& CommonTableExpr::aliascolnames(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.aliascolnames)
  return _internal_aliascolnames(index);
}
inline ::pg_query::Node* CommonTableExpr::_internal_add_aliascolnames() {
  return aliascolnames_.Add();
}
inline ::pg_query::Node* CommonTableExpr::add_aliascolnames() {
  // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.aliascolnames)
  return _internal_add_aliascolnames();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CommonTableExpr::aliascolnames() const {
  // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.aliascolnames)
  return aliascolnames_;
}

// .pg_query.CTEMaterialize ctematerialized = 3 [json_name = "ctematerialized"];
inline void CommonTableExpr::clear_ctematerialized() {
  ctematerialized_ = 0;
}
inline ::pg_query::CTEMaterialize CommonTableExpr::_internal_ctematerialized() const {
  return static_cast< ::pg_query::CTEMaterialize >(ctematerialized_);
}
inline ::pg_query::CTEMaterialize CommonTableExpr::ctematerialized() const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctematerialized)
  return _internal_ctematerialized();
}
inline void CommonTableExpr::_internal_set_ctematerialized(::pg_query::CTEMaterialize value) {
  
  ctematerialized_ = value;
}
inline void CommonTableExpr::set_ctematerialized(::pg_query::CTEMaterialize value) {
  _internal_set_ctematerialized(value);
  // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.ctematerialized)
}

// .pg_query.Node ctequery = 4 [json_name = "ctequery"];
inline bool CommonTableExpr::_internal_has_ctequery() const {
  return this != internal_default_instance() && ctequery_ != nullptr;
}
inline bool CommonTableExpr::has_ctequery() const {
  return _internal_has_ctequery();
}
inline void CommonTableExpr::clear_ctequery() {
  if (GetArena() == nullptr && ctequery_ != nullptr) {
    delete ctequery_;
  }
  ctequery_ = nullptr;
}
inline const ::pg_query::Node& CommonTableExpr::_internal_ctequery() const {
  const ::pg_query::Node* p = ctequery_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CommonTableExpr::ctequery() const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctequery)
  return _internal_ctequery();
}
inline void CommonTableExpr::unsafe_arena_set_allocated_ctequery(
    ::pg_query::Node* ctequery) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(ctequery_);
  }
  ctequery_ = ctequery;
  if (ctequery) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CommonTableExpr.ctequery)
}
inline ::pg_query::Node* CommonTableExpr::release_ctequery() {
  
  ::pg_query::Node* temp = ctequery_;
  ctequery_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* CommonTableExpr::unsafe_arena_release_ctequery() {
  // @@protoc_insertion_point(field_release:pg_query.CommonTableExpr.ctequery)
  
  ::pg_query::Node* temp = ctequery_;
  ctequery_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CommonTableExpr::_internal_mutable_ctequery() {
  
  if (ctequery_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    ctequery_ = p;
  }
  return ctequery_;
}
inline ::pg_query::Node* CommonTableExpr::mutable_ctequery() {
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctequery)
  return _internal_mutable_ctequery();
}
inline void CommonTableExpr::set_allocated_ctequery(::pg_query::Node* ctequery) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete ctequery_;
  }
  if (ctequery) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(ctequery);
    if (message_arena != submessage_arena) {
      ctequery = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ctequery, submessage_arena);
    }
    
  } else {
    
  }
  ctequery_ = ctequery;
  // @@protoc_insertion_point(field_set_allocated:pg_query.CommonTableExpr.ctequery)
}

// int32 location = 5 [json_name = "location"];
inline void CommonTableExpr::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CommonTableExpr::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CommonTableExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.location)
  return _internal_location();
}
inline void CommonTableExpr::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void CommonTableExpr::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.location)
}

// bool cterecursive = 6 [json_name = "cterecursive"];
inline void CommonTableExpr::clear_cterecursive() {
  cterecursive_ = false;
}
inline bool CommonTableExpr::_internal_cterecursive() const {
  return cterecursive_;
}
inline bool CommonTableExpr::cterecursive() const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.cterecursive)
  return _internal_cterecursive();
}
inline void CommonTableExpr::_internal_set_cterecursive(bool value) {
  
  cterecursive_ = value;
}
inline void CommonTableExpr::set_cterecursive(bool value) {
  _internal_set_cterecursive(value);
  // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.cterecursive)
}

// int32 cterefcount = 7 [json_name = "cterefcount"];
inline void CommonTableExpr::clear_cterefcount() {
  cterefcount_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CommonTableExpr::_internal_cterefcount() const {
  return cterefcount_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 CommonTableExpr::cterefcount() const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.cterefcount)
  return _internal_cterefcount();
}
inline void CommonTableExpr::_internal_set_cterefcount(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  cterefcount_ = value;
}
inline void CommonTableExpr::set_cterefcount(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_cterefcount(value);
  // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.cterefcount)
}

// repeated .pg_query.Node ctecolnames = 8 [json_name = "ctecolnames"];
inline int CommonTableExpr::_internal_ctecolnames_size() const {
  return ctecolnames_.size();
}
inline int CommonTableExpr::ctecolnames_size() const {
  return _internal_ctecolnames_size();
}
inline void CommonTableExpr::clear_ctecolnames() {
  ctecolnames_.Clear();
}
inline ::pg_query::Node* CommonTableExpr::mutable_ctecolnames(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctecolnames)
  return ctecolnames_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CommonTableExpr::mutable_ctecolnames() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.ctecolnames)
  return &ctecolnames_;
}
inline const ::pg_query::Node& CommonTableExpr::_internal_ctecolnames(int index) const {
  return ctecolnames_.Get(index);
}
inline const ::pg_query::Node& CommonTableExpr::ctecolnames(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctecolnames)
  return _internal_ctecolnames(index);
}
inline ::pg_query::Node* CommonTableExpr::_internal_add_ctecolnames() {
  return ctecolnames_.Add();
}
inline ::pg_query::Node* CommonTableExpr::add_ctecolnames() {
  // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.ctecolnames)
  return _internal_add_ctecolnames();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CommonTableExpr::ctecolnames() const {
  // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.ctecolnames)
  return ctecolnames_;
}

// repeated .pg_query.Node ctecoltypes = 9 [json_name = "ctecoltypes"];
inline int CommonTableExpr::_internal_ctecoltypes_size() const {
  return ctecoltypes_.size();
}
inline int CommonTableExpr::ctecoltypes_size() const {
  return _internal_ctecoltypes_size();
}
inline void CommonTableExpr::clear_ctecoltypes() {
  ctecoltypes_.Clear();
}
inline ::pg_query::Node* CommonTableExpr::mutable_ctecoltypes(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctecoltypes)
  return ctecoltypes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CommonTableExpr::mutable_ctecoltypes() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.ctecoltypes)
  return &ctecoltypes_;
}
inline const ::pg_query::Node& CommonTableExpr::_internal_ctecoltypes(int index) const {
  return ctecoltypes_.Get(index);
}
inline const ::pg_query::Node& CommonTableExpr::ctecoltypes(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctecoltypes)
  return _internal_ctecoltypes(index);
}
inline ::pg_query::Node* CommonTableExpr::_internal_add_ctecoltypes() {
  return ctecoltypes_.Add();
}
inline ::pg_query::Node* CommonTableExpr::add_ctecoltypes() {
  // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.ctecoltypes)
  return _internal_add_ctecoltypes();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CommonTableExpr::ctecoltypes() const {
  // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.ctecoltypes)
  return ctecoltypes_;
}

// repeated .pg_query.Node ctecoltypmods = 10 [json_name = "ctecoltypmods"];
inline int CommonTableExpr::_internal_ctecoltypmods_size() const {
  return ctecoltypmods_.size();
}
inline int CommonTableExpr::ctecoltypmods_size() const {
  return _internal_ctecoltypmods_size();
}
inline void CommonTableExpr::clear_ctecoltypmods() {
  ctecoltypmods_.Clear();
}
inline ::pg_query::Node* CommonTableExpr::mutable_ctecoltypmods(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctecoltypmods)
  return ctecoltypmods_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CommonTableExpr::mutable_ctecoltypmods() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.ctecoltypmods)
  return &ctecoltypmods_;
}
inline const ::pg_query::Node& CommonTableExpr::_internal_ctecoltypmods(int index) const {
  return ctecoltypmods_.Get(index);
}
inline const ::pg_query::Node& CommonTableExpr::ctecoltypmods(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctecoltypmods)
  return _internal_ctecoltypmods(index);
}
inline ::pg_query::Node* CommonTableExpr::_internal_add_ctecoltypmods() {
  return ctecoltypmods_.Add();
}
inline ::pg_query::Node* CommonTableExpr::add_ctecoltypmods() {
  // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.ctecoltypmods)
  return _internal_add_ctecoltypmods();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CommonTableExpr::ctecoltypmods() const {
  // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.ctecoltypmods)
  return ctecoltypmods_;
}

// repeated .pg_query.Node ctecolcollations = 11 [json_name = "ctecolcollations"];
inline int CommonTableExpr::_internal_ctecolcollations_size() const {
  return ctecolcollations_.size();
}
inline int CommonTableExpr::ctecolcollations_size() const {
  return _internal_ctecolcollations_size();
}
inline void CommonTableExpr::clear_ctecolcollations() {
  ctecolcollations_.Clear();
}
inline ::pg_query::Node* CommonTableExpr::mutable_ctecolcollations(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctecolcollations)
  return ctecolcollations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
CommonTableExpr::mutable_ctecolcollations() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.ctecolcollations)
  return &ctecolcollations_;
}
inline const ::pg_query::Node& CommonTableExpr::_internal_ctecolcollations(int index) const {
  return ctecolcollations_.Get(index);
}
inline const ::pg_query::Node& CommonTableExpr::ctecolcollations(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctecolcollations)
  return _internal_ctecolcollations(index);
}
inline ::pg_query::Node* CommonTableExpr::_internal_add_ctecolcollations() {
  return ctecolcollations_.Add();
}
inline ::pg_query::Node* CommonTableExpr::add_ctecolcollations() {
  // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.ctecolcollations)
  return _internal_add_ctecolcollations();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
CommonTableExpr::ctecolcollations() const {
  // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.ctecolcollations)
  return ctecolcollations_;
}

// -------------------------------------------------------------------

// RoleSpec

// .pg_query.RoleSpecType roletype = 1 [json_name = "roletype"];
inline void RoleSpec::clear_roletype() {
  roletype_ = 0;
}
inline ::pg_query::RoleSpecType RoleSpec::_internal_roletype() const {
  return static_cast< ::pg_query::RoleSpecType >(roletype_);
}
inline ::pg_query::RoleSpecType RoleSpec::roletype() const {
  // @@protoc_insertion_point(field_get:pg_query.RoleSpec.roletype)
  return _internal_roletype();
}
inline void RoleSpec::_internal_set_roletype(::pg_query::RoleSpecType value) {
  
  roletype_ = value;
}
inline void RoleSpec::set_roletype(::pg_query::RoleSpecType value) {
  _internal_set_roletype(value);
  // @@protoc_insertion_point(field_set:pg_query.RoleSpec.roletype)
}

// string rolename = 2 [json_name = "rolename"];
inline void RoleSpec::clear_rolename() {
  rolename_.ClearToEmpty();
}
inline const std::string& RoleSpec::rolename() const {
  // @@protoc_insertion_point(field_get:pg_query.RoleSpec.rolename)
  return _internal_rolename();
}
inline void RoleSpec::set_rolename(const std::string& value) {
  _internal_set_rolename(value);
  // @@protoc_insertion_point(field_set:pg_query.RoleSpec.rolename)
}
inline std::string* RoleSpec::mutable_rolename() {
  // @@protoc_insertion_point(field_mutable:pg_query.RoleSpec.rolename)
  return _internal_mutable_rolename();
}
inline const std::string& RoleSpec::_internal_rolename() const {
  return rolename_.Get();
}
inline void RoleSpec::_internal_set_rolename(const std::string& value) {
  
  rolename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RoleSpec::set_rolename(std::string&& value) {
  
  rolename_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.RoleSpec.rolename)
}
inline void RoleSpec::set_rolename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  rolename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.RoleSpec.rolename)
}
inline void RoleSpec::set_rolename(const char* value,
    size_t size) {
  
  rolename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.RoleSpec.rolename)
}
inline std::string* RoleSpec::_internal_mutable_rolename() {
  
  return rolename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RoleSpec::release_rolename() {
  // @@protoc_insertion_point(field_release:pg_query.RoleSpec.rolename)
  return rolename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RoleSpec::set_allocated_rolename(std::string* rolename) {
  if (rolename != nullptr) {
    
  } else {
    
  }
  rolename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), rolename,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.RoleSpec.rolename)
}

// int32 location = 3 [json_name = "location"];
inline void RoleSpec::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RoleSpec::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RoleSpec::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RoleSpec.location)
  return _internal_location();
}
inline void RoleSpec::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void RoleSpec::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RoleSpec.location)
}

// -------------------------------------------------------------------

// TriggerTransition

// string name = 1 [json_name = "name"];
inline void TriggerTransition::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& TriggerTransition::name() const {
  // @@protoc_insertion_point(field_get:pg_query.TriggerTransition.name)
  return _internal_name();
}
inline void TriggerTransition::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.TriggerTransition.name)
}
inline std::string* TriggerTransition::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.TriggerTransition.name)
  return _internal_mutable_name();
}
inline const std::string& TriggerTransition::_internal_name() const {
  return name_.Get();
}
inline void TriggerTransition::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void TriggerTransition::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.TriggerTransition.name)
}
inline void TriggerTransition::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.TriggerTransition.name)
}
inline void TriggerTransition::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.TriggerTransition.name)
}
inline std::string* TriggerTransition::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* TriggerTransition::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.TriggerTransition.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void TriggerTransition::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.TriggerTransition.name)
}

// bool is_new = 2 [json_name = "isNew"];
inline void TriggerTransition::clear_is_new() {
  is_new_ = false;
}
inline bool TriggerTransition::_internal_is_new() const {
  return is_new_;
}
inline bool TriggerTransition::is_new() const {
  // @@protoc_insertion_point(field_get:pg_query.TriggerTransition.is_new)
  return _internal_is_new();
}
inline void TriggerTransition::_internal_set_is_new(bool value) {
  
  is_new_ = value;
}
inline void TriggerTransition::set_is_new(bool value) {
  _internal_set_is_new(value);
  // @@protoc_insertion_point(field_set:pg_query.TriggerTransition.is_new)
}

// bool is_table = 3 [json_name = "isTable"];
inline void TriggerTransition::clear_is_table() {
  is_table_ = false;
}
inline bool TriggerTransition::_internal_is_table() const {
  return is_table_;
}
inline bool TriggerTransition::is_table() const {
  // @@protoc_insertion_point(field_get:pg_query.TriggerTransition.is_table)
  return _internal_is_table();
}
inline void TriggerTransition::_internal_set_is_table(bool value) {
  
  is_table_ = value;
}
inline void TriggerTransition::set_is_table(bool value) {
  _internal_set_is_table(value);
  // @@protoc_insertion_point(field_set:pg_query.TriggerTransition.is_table)
}

// -------------------------------------------------------------------

// PartitionElem

// string name = 1 [json_name = "name"];
inline void PartitionElem::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& PartitionElem::name() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionElem.name)
  return _internal_name();
}
inline void PartitionElem::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionElem.name)
}
inline std::string* PartitionElem::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionElem.name)
  return _internal_mutable_name();
}
inline const std::string& PartitionElem::_internal_name() const {
  return name_.Get();
}
inline void PartitionElem::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void PartitionElem::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.PartitionElem.name)
}
inline void PartitionElem::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.PartitionElem.name)
}
inline void PartitionElem::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.PartitionElem.name)
}
inline std::string* PartitionElem::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* PartitionElem::release_name() {
  // @@protoc_insertion_point(field_release:pg_query.PartitionElem.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void PartitionElem::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionElem.name)
}

// .pg_query.Node expr = 2 [json_name = "expr"];
inline bool PartitionElem::_internal_has_expr() const {
  return this != internal_default_instance() && expr_ != nullptr;
}
inline bool PartitionElem::has_expr() const {
  return _internal_has_expr();
}
inline void PartitionElem::clear_expr() {
  if (GetArena() == nullptr && expr_ != nullptr) {
    delete expr_;
  }
  expr_ = nullptr;
}
inline const ::pg_query::Node& PartitionElem::_internal_expr() const {
  const ::pg_query::Node* p = expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& PartitionElem::expr() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionElem.expr)
  return _internal_expr();
}
inline void PartitionElem::unsafe_arena_set_allocated_expr(
    ::pg_query::Node* expr) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expr_);
  }
  expr_ = expr;
  if (expr) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PartitionElem.expr)
}
inline ::pg_query::Node* PartitionElem::release_expr() {
  
  ::pg_query::Node* temp = expr_;
  expr_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* PartitionElem::unsafe_arena_release_expr() {
  // @@protoc_insertion_point(field_release:pg_query.PartitionElem.expr)
  
  ::pg_query::Node* temp = expr_;
  expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* PartitionElem::_internal_mutable_expr() {
  
  if (expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    expr_ = p;
  }
  return expr_;
}
inline ::pg_query::Node* PartitionElem::mutable_expr() {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionElem.expr)
  return _internal_mutable_expr();
}
inline void PartitionElem::set_allocated_expr(::pg_query::Node* expr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete expr_;
  }
  if (expr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expr);
    if (message_arena != submessage_arena) {
      expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, expr, submessage_arena);
    }
    
  } else {
    
  }
  expr_ = expr;
  // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionElem.expr)
}

// repeated .pg_query.Node collation = 3 [json_name = "collation"];
inline int PartitionElem::_internal_collation_size() const {
  return collation_.size();
}
inline int PartitionElem::collation_size() const {
  return _internal_collation_size();
}
inline void PartitionElem::clear_collation() {
  collation_.Clear();
}
inline ::pg_query::Node* PartitionElem::mutable_collation(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionElem.collation)
  return collation_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
PartitionElem::mutable_collation() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionElem.collation)
  return &collation_;
}
inline const ::pg_query::Node& PartitionElem::_internal_collation(int index) const {
  return collation_.Get(index);
}
inline const ::pg_query::Node& PartitionElem::collation(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionElem.collation)
  return _internal_collation(index);
}
inline ::pg_query::Node* PartitionElem::_internal_add_collation() {
  return collation_.Add();
}
inline ::pg_query::Node* PartitionElem::add_collation() {
  // @@protoc_insertion_point(field_add:pg_query.PartitionElem.collation)
  return _internal_add_collation();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
PartitionElem::collation() const {
  // @@protoc_insertion_point(field_list:pg_query.PartitionElem.collation)
  return collation_;
}

// repeated .pg_query.Node opclass = 4 [json_name = "opclass"];
inline int PartitionElem::_internal_opclass_size() const {
  return opclass_.size();
}
inline int PartitionElem::opclass_size() const {
  return _internal_opclass_size();
}
inline void PartitionElem::clear_opclass() {
  opclass_.Clear();
}
inline ::pg_query::Node* PartitionElem::mutable_opclass(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionElem.opclass)
  return opclass_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
PartitionElem::mutable_opclass() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionElem.opclass)
  return &opclass_;
}
inline const ::pg_query::Node& PartitionElem::_internal_opclass(int index) const {
  return opclass_.Get(index);
}
inline const ::pg_query::Node& PartitionElem::opclass(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionElem.opclass)
  return _internal_opclass(index);
}
inline ::pg_query::Node* PartitionElem::_internal_add_opclass() {
  return opclass_.Add();
}
inline ::pg_query::Node* PartitionElem::add_opclass() {
  // @@protoc_insertion_point(field_add:pg_query.PartitionElem.opclass)
  return _internal_add_opclass();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
PartitionElem::opclass() const {
  // @@protoc_insertion_point(field_list:pg_query.PartitionElem.opclass)
  return opclass_;
}

// int32 location = 5 [json_name = "location"];
inline void PartitionElem::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionElem::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionElem::location() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionElem.location)
  return _internal_location();
}
inline void PartitionElem::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void PartitionElem::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionElem.location)
}

// -------------------------------------------------------------------

// PartitionSpec

// string strategy = 1 [json_name = "strategy"];
inline void PartitionSpec::clear_strategy() {
  strategy_.ClearToEmpty();
}
inline const std::string& PartitionSpec::strategy() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionSpec.strategy)
  return _internal_strategy();
}
inline void PartitionSpec::set_strategy(const std::string& value) {
  _internal_set_strategy(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionSpec.strategy)
}
inline std::string* PartitionSpec::mutable_strategy() {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionSpec.strategy)
  return _internal_mutable_strategy();
}
inline const std::string& PartitionSpec::_internal_strategy() const {
  return strategy_.Get();
}
inline void PartitionSpec::_internal_set_strategy(const std::string& value) {
  
  strategy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void PartitionSpec::set_strategy(std::string&& value) {
  
  strategy_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.PartitionSpec.strategy)
}
inline void PartitionSpec::set_strategy(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  strategy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.PartitionSpec.strategy)
}
inline void PartitionSpec::set_strategy(const char* value,
    size_t size) {
  
  strategy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.PartitionSpec.strategy)
}
inline std::string* PartitionSpec::_internal_mutable_strategy() {
  
  return strategy_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* PartitionSpec::release_strategy() {
  // @@protoc_insertion_point(field_release:pg_query.PartitionSpec.strategy)
  return strategy_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void PartitionSpec::set_allocated_strategy(std::string* strategy) {
  if (strategy != nullptr) {
    
  } else {
    
  }
  strategy_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), strategy,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionSpec.strategy)
}

// repeated .pg_query.Node part_params = 2 [json_name = "partParams"];
inline int PartitionSpec::_internal_part_params_size() const {
  return part_params_.size();
}
inline int PartitionSpec::part_params_size() const {
  return _internal_part_params_size();
}
inline void PartitionSpec::clear_part_params() {
  part_params_.Clear();
}
inline ::pg_query::Node* PartitionSpec::mutable_part_params(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionSpec.part_params)
  return part_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
PartitionSpec::mutable_part_params() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionSpec.part_params)
  return &part_params_;
}
inline const ::pg_query::Node& PartitionSpec::_internal_part_params(int index) const {
  return part_params_.Get(index);
}
inline const ::pg_query::Node& PartitionSpec::part_params(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionSpec.part_params)
  return _internal_part_params(index);
}
inline ::pg_query::Node* PartitionSpec::_internal_add_part_params() {
  return part_params_.Add();
}
inline ::pg_query::Node* PartitionSpec::add_part_params() {
  // @@protoc_insertion_point(field_add:pg_query.PartitionSpec.part_params)
  return _internal_add_part_params();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
PartitionSpec::part_params() const {
  // @@protoc_insertion_point(field_list:pg_query.PartitionSpec.part_params)
  return part_params_;
}

// int32 location = 3 [json_name = "location"];
inline void PartitionSpec::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionSpec::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionSpec::location() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionSpec.location)
  return _internal_location();
}
inline void PartitionSpec::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void PartitionSpec::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionSpec.location)
}

// -------------------------------------------------------------------

// PartitionBoundSpec

// string strategy = 1 [json_name = "strategy"];
inline void PartitionBoundSpec::clear_strategy() {
  strategy_.ClearToEmpty();
}
inline const std::string& PartitionBoundSpec::strategy() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.strategy)
  return _internal_strategy();
}
inline void PartitionBoundSpec::set_strategy(const std::string& value) {
  _internal_set_strategy(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.strategy)
}
inline std::string* PartitionBoundSpec::mutable_strategy() {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionBoundSpec.strategy)
  return _internal_mutable_strategy();
}
inline const std::string& PartitionBoundSpec::_internal_strategy() const {
  return strategy_.Get();
}
inline void PartitionBoundSpec::_internal_set_strategy(const std::string& value) {
  
  strategy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void PartitionBoundSpec::set_strategy(std::string&& value) {
  
  strategy_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.PartitionBoundSpec.strategy)
}
inline void PartitionBoundSpec::set_strategy(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  strategy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.PartitionBoundSpec.strategy)
}
inline void PartitionBoundSpec::set_strategy(const char* value,
    size_t size) {
  
  strategy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.PartitionBoundSpec.strategy)
}
inline std::string* PartitionBoundSpec::_internal_mutable_strategy() {
  
  return strategy_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* PartitionBoundSpec::release_strategy() {
  // @@protoc_insertion_point(field_release:pg_query.PartitionBoundSpec.strategy)
  return strategy_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void PartitionBoundSpec::set_allocated_strategy(std::string* strategy) {
  if (strategy != nullptr) {
    
  } else {
    
  }
  strategy_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), strategy,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionBoundSpec.strategy)
}

// bool is_default = 2 [json_name = "is_default"];
inline void PartitionBoundSpec::clear_is_default() {
  is_default_ = false;
}
inline bool PartitionBoundSpec::_internal_is_default() const {
  return is_default_;
}
inline bool PartitionBoundSpec::is_default() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.is_default)
  return _internal_is_default();
}
inline void PartitionBoundSpec::_internal_set_is_default(bool value) {
  
  is_default_ = value;
}
inline void PartitionBoundSpec::set_is_default(bool value) {
  _internal_set_is_default(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.is_default)
}

// int32 modulus = 3 [json_name = "modulus"];
inline void PartitionBoundSpec::clear_modulus() {
  modulus_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionBoundSpec::_internal_modulus() const {
  return modulus_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionBoundSpec::modulus() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.modulus)
  return _internal_modulus();
}
inline void PartitionBoundSpec::_internal_set_modulus(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  modulus_ = value;
}
inline void PartitionBoundSpec::set_modulus(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_modulus(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.modulus)
}

// int32 remainder = 4 [json_name = "remainder"];
inline void PartitionBoundSpec::clear_remainder() {
  remainder_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionBoundSpec::_internal_remainder() const {
  return remainder_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionBoundSpec::remainder() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.remainder)
  return _internal_remainder();
}
inline void PartitionBoundSpec::_internal_set_remainder(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  remainder_ = value;
}
inline void PartitionBoundSpec::set_remainder(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_remainder(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.remainder)
}

// repeated .pg_query.Node listdatums = 5 [json_name = "listdatums"];
inline int PartitionBoundSpec::_internal_listdatums_size() const {
  return listdatums_.size();
}
inline int PartitionBoundSpec::listdatums_size() const {
  return _internal_listdatums_size();
}
inline void PartitionBoundSpec::clear_listdatums() {
  listdatums_.Clear();
}
inline ::pg_query::Node* PartitionBoundSpec::mutable_listdatums(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionBoundSpec.listdatums)
  return listdatums_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
PartitionBoundSpec::mutable_listdatums() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionBoundSpec.listdatums)
  return &listdatums_;
}
inline const ::pg_query::Node& PartitionBoundSpec::_internal_listdatums(int index) const {
  return listdatums_.Get(index);
}
inline const ::pg_query::Node& PartitionBoundSpec::listdatums(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.listdatums)
  return _internal_listdatums(index);
}
inline ::pg_query::Node* PartitionBoundSpec::_internal_add_listdatums() {
  return listdatums_.Add();
}
inline ::pg_query::Node* PartitionBoundSpec::add_listdatums() {
  // @@protoc_insertion_point(field_add:pg_query.PartitionBoundSpec.listdatums)
  return _internal_add_listdatums();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
PartitionBoundSpec::listdatums() const {
  // @@protoc_insertion_point(field_list:pg_query.PartitionBoundSpec.listdatums)
  return listdatums_;
}

// repeated .pg_query.Node lowerdatums = 6 [json_name = "lowerdatums"];
inline int PartitionBoundSpec::_internal_lowerdatums_size() const {
  return lowerdatums_.size();
}
inline int PartitionBoundSpec::lowerdatums_size() const {
  return _internal_lowerdatums_size();
}
inline void PartitionBoundSpec::clear_lowerdatums() {
  lowerdatums_.Clear();
}
inline ::pg_query::Node* PartitionBoundSpec::mutable_lowerdatums(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionBoundSpec.lowerdatums)
  return lowerdatums_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
PartitionBoundSpec::mutable_lowerdatums() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionBoundSpec.lowerdatums)
  return &lowerdatums_;
}
inline const ::pg_query::Node& PartitionBoundSpec::_internal_lowerdatums(int index) const {
  return lowerdatums_.Get(index);
}
inline const ::pg_query::Node& PartitionBoundSpec::lowerdatums(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.lowerdatums)
  return _internal_lowerdatums(index);
}
inline ::pg_query::Node* PartitionBoundSpec::_internal_add_lowerdatums() {
  return lowerdatums_.Add();
}
inline ::pg_query::Node* PartitionBoundSpec::add_lowerdatums() {
  // @@protoc_insertion_point(field_add:pg_query.PartitionBoundSpec.lowerdatums)
  return _internal_add_lowerdatums();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
PartitionBoundSpec::lowerdatums() const {
  // @@protoc_insertion_point(field_list:pg_query.PartitionBoundSpec.lowerdatums)
  return lowerdatums_;
}

// repeated .pg_query.Node upperdatums = 7 [json_name = "upperdatums"];
inline int PartitionBoundSpec::_internal_upperdatums_size() const {
  return upperdatums_.size();
}
inline int PartitionBoundSpec::upperdatums_size() const {
  return _internal_upperdatums_size();
}
inline void PartitionBoundSpec::clear_upperdatums() {
  upperdatums_.Clear();
}
inline ::pg_query::Node* PartitionBoundSpec::mutable_upperdatums(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionBoundSpec.upperdatums)
  return upperdatums_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
PartitionBoundSpec::mutable_upperdatums() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionBoundSpec.upperdatums)
  return &upperdatums_;
}
inline const ::pg_query::Node& PartitionBoundSpec::_internal_upperdatums(int index) const {
  return upperdatums_.Get(index);
}
inline const ::pg_query::Node& PartitionBoundSpec::upperdatums(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.upperdatums)
  return _internal_upperdatums(index);
}
inline ::pg_query::Node* PartitionBoundSpec::_internal_add_upperdatums() {
  return upperdatums_.Add();
}
inline ::pg_query::Node* PartitionBoundSpec::add_upperdatums() {
  // @@protoc_insertion_point(field_add:pg_query.PartitionBoundSpec.upperdatums)
  return _internal_add_upperdatums();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
PartitionBoundSpec::upperdatums() const {
  // @@protoc_insertion_point(field_list:pg_query.PartitionBoundSpec.upperdatums)
  return upperdatums_;
}

// int32 location = 8 [json_name = "location"];
inline void PartitionBoundSpec::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionBoundSpec::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionBoundSpec::location() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.location)
  return _internal_location();
}
inline void PartitionBoundSpec::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void PartitionBoundSpec::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.location)
}

// -------------------------------------------------------------------

// PartitionRangeDatum

// .pg_query.PartitionRangeDatumKind kind = 1 [json_name = "kind"];
inline void PartitionRangeDatum::clear_kind() {
  kind_ = 0;
}
inline ::pg_query::PartitionRangeDatumKind PartitionRangeDatum::_internal_kind() const {
  return static_cast< ::pg_query::PartitionRangeDatumKind >(kind_);
}
inline ::pg_query::PartitionRangeDatumKind PartitionRangeDatum::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionRangeDatum.kind)
  return _internal_kind();
}
inline void PartitionRangeDatum::_internal_set_kind(::pg_query::PartitionRangeDatumKind value) {
  
  kind_ = value;
}
inline void PartitionRangeDatum::set_kind(::pg_query::PartitionRangeDatumKind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionRangeDatum.kind)
}

// .pg_query.Node value = 2 [json_name = "value"];
inline bool PartitionRangeDatum::_internal_has_value() const {
  return this != internal_default_instance() && value_ != nullptr;
}
inline bool PartitionRangeDatum::has_value() const {
  return _internal_has_value();
}
inline void PartitionRangeDatum::clear_value() {
  if (GetArena() == nullptr && value_ != nullptr) {
    delete value_;
  }
  value_ = nullptr;
}
inline const ::pg_query::Node& PartitionRangeDatum::_internal_value() const {
  const ::pg_query::Node* p = value_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(
      ::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& PartitionRangeDatum::value() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionRangeDatum.value)
  return _internal_value();
}
inline void PartitionRangeDatum::unsafe_arena_set_allocated_value(
    ::pg_query::Node* value) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_);
  }
  value_ = value;
  if (value) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PartitionRangeDatum.value)
}
inline ::pg_query::Node* PartitionRangeDatum::release_value() {
  
  ::pg_query::Node* temp = value_;
  value_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::Node* PartitionRangeDatum::unsafe_arena_release_value() {
  // @@protoc_insertion_point(field_release:pg_query.PartitionRangeDatum.value)
  
  ::pg_query::Node* temp = value_;
  value_ = nullptr;
  return temp;
}
inline ::pg_query::Node* PartitionRangeDatum::_internal_mutable_value() {
  
  if (value_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    value_ = p;
  }
  return value_;
}
inline ::pg_query::Node* PartitionRangeDatum::mutable_value() {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionRangeDatum.value)
  return _internal_mutable_value();
}
inline void PartitionRangeDatum::set_allocated_value(::pg_query::Node* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete value_;
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value);
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    
  } else {
    
  }
  value_ = value;
  // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionRangeDatum.value)
}

// int32 location = 3 [json_name = "location"];
inline void PartitionRangeDatum::clear_location() {
  location_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionRangeDatum::_internal_location() const {
  return location_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionRangeDatum::location() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionRangeDatum.location)
  return _internal_location();
}
inline void PartitionRangeDatum::_internal_set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  location_ = value;
}
inline void PartitionRangeDatum::set_location(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionRangeDatum.location)
}

// -------------------------------------------------------------------

// PartitionCmd

// .pg_query.RangeVar name = 1 [json_name = "name"];
inline bool PartitionCmd::_internal_has_name() const {
  return this != internal_default_instance() && name_ != nullptr;
}
inline bool PartitionCmd::has_name() const {
  return _internal_has_name();
}
inline void PartitionCmd::clear_name() {
  if (GetArena() == nullptr && name_ != nullptr) {
    delete name_;
  }
  name_ = nullptr;
}
inline const ::pg_query::RangeVar& PartitionCmd::_internal_name() const {
  const ::pg_query::RangeVar* p = name_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& PartitionCmd::name() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionCmd.name)
  return _internal_name();
}
inline void PartitionCmd::unsafe_arena_set_allocated_name(
    ::pg_query::RangeVar* name) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(name_);
  }
  name_ = name;
  if (name) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PartitionCmd.name)
}
inline ::pg_query::RangeVar* PartitionCmd::release_name() {
  
  ::pg_query::RangeVar* temp = name_;
  name_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* PartitionCmd::unsafe_arena_release_name() {
  // @@protoc_insertion_point(field_release:pg_query.PartitionCmd.name)
  
  ::pg_query::RangeVar* temp = name_;
  name_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* PartitionCmd::_internal_mutable_name() {
  
  if (name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    name_ = p;
  }
  return name_;
}
inline ::pg_query::RangeVar* PartitionCmd::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionCmd.name)
  return _internal_mutable_name();
}
inline void PartitionCmd::set_allocated_name(::pg_query::RangeVar* name) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete name_;
  }
  if (name) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(name);
    if (message_arena != submessage_arena) {
      name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, name, submessage_arena);
    }
    
  } else {
    
  }
  name_ = name;
  // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionCmd.name)
}

// .pg_query.PartitionBoundSpec bound = 2 [json_name = "bound"];
inline bool PartitionCmd::_internal_has_bound() const {
  return this != internal_default_instance() && bound_ != nullptr;
}
inline bool PartitionCmd::has_bound() const {
  return _internal_has_bound();
}
inline void PartitionCmd::clear_bound() {
  if (GetArena() == nullptr && bound_ != nullptr) {
    delete bound_;
  }
  bound_ = nullptr;
}
inline const ::pg_query::PartitionBoundSpec& PartitionCmd::_internal_bound() const {
  const ::pg_query::PartitionBoundSpec* p = bound_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::PartitionBoundSpec&>(
      ::pg_query::_PartitionBoundSpec_default_instance_);
}
inline const ::pg_query::PartitionBoundSpec& PartitionCmd::bound() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionCmd.bound)
  return _internal_bound();
}
inline void PartitionCmd::unsafe_arena_set_allocated_bound(
    ::pg_query::PartitionBoundSpec* bound) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bound_);
  }
  bound_ = bound;
  if (bound) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PartitionCmd.bound)
}
inline ::pg_query::PartitionBoundSpec* PartitionCmd::release_bound() {
  
  ::pg_query::PartitionBoundSpec* temp = bound_;
  bound_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::PartitionBoundSpec* PartitionCmd::unsafe_arena_release_bound() {
  // @@protoc_insertion_point(field_release:pg_query.PartitionCmd.bound)
  
  ::pg_query::PartitionBoundSpec* temp = bound_;
  bound_ = nullptr;
  return temp;
}
inline ::pg_query::PartitionBoundSpec* PartitionCmd::_internal_mutable_bound() {
  
  if (bound_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::PartitionBoundSpec>(GetArena());
    bound_ = p;
  }
  return bound_;
}
inline ::pg_query::PartitionBoundSpec* PartitionCmd::mutable_bound() {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionCmd.bound)
  return _internal_mutable_bound();
}
inline void PartitionCmd::set_allocated_bound(::pg_query::PartitionBoundSpec* bound) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete bound_;
  }
  if (bound) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(bound);
    if (message_arena != submessage_arena) {
      bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bound, submessage_arena);
    }
    
  } else {
    
  }
  bound_ = bound;
  // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionCmd.bound)
}

// -------------------------------------------------------------------

// VacuumRelation

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool VacuumRelation::_internal_has_relation() const {
  return this != internal_default_instance() && relation_ != nullptr;
}
inline bool VacuumRelation::has_relation() const {
  return _internal_has_relation();
}
inline void VacuumRelation::clear_relation() {
  if (GetArena() == nullptr && relation_ != nullptr) {
    delete relation_;
  }
  relation_ = nullptr;
}
inline const ::pg_query::RangeVar& VacuumRelation::_internal_relation() const {
  const ::pg_query::RangeVar* p = relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(
      ::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& VacuumRelation::relation() const {
  // @@protoc_insertion_point(field_get:pg_query.VacuumRelation.relation)
  return _internal_relation();
}
inline void VacuumRelation::unsafe_arena_set_allocated_relation(
    ::pg_query::RangeVar* relation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relation_);
  }
  relation_ = relation;
  if (relation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.VacuumRelation.relation)
}
inline ::pg_query::RangeVar* VacuumRelation::release_relation() {
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pg_query::RangeVar* VacuumRelation::unsafe_arena_release_relation() {
  // @@protoc_insertion_point(field_release:pg_query.VacuumRelation.relation)
  
  ::pg_query::RangeVar* temp = relation_;
  relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* VacuumRelation::_internal_mutable_relation() {
  
  if (relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    relation_ = p;
  }
  return relation_;
}
inline ::pg_query::RangeVar* VacuumRelation::mutable_relation() {
  // @@protoc_insertion_point(field_mutable:pg_query.VacuumRelation.relation)
  return _internal_mutable_relation();
}
inline void VacuumRelation::set_allocated_relation(::pg_query::RangeVar* relation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete relation_;
  }
  if (relation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(relation);
    if (message_arena != submessage_arena) {
      relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relation, submessage_arena);
    }
    
  } else {
    
  }
  relation_ = relation;
  // @@protoc_insertion_point(field_set_allocated:pg_query.VacuumRelation.relation)
}

// uint32 oid = 2 [json_name = "oid"];
inline void VacuumRelation::clear_oid() {
  oid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 VacuumRelation::_internal_oid() const {
  return oid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 VacuumRelation::oid() const {
  // @@protoc_insertion_point(field_get:pg_query.VacuumRelation.oid)
  return _internal_oid();
}
inline void VacuumRelation::_internal_set_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  oid_ = value;
}
inline void VacuumRelation::set_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.VacuumRelation.oid)
}

// repeated .pg_query.Node va_cols = 3 [json_name = "va_cols"];
inline int VacuumRelation::_internal_va_cols_size() const {
  return va_cols_.size();
}
inline int VacuumRelation::va_cols_size() const {
  return _internal_va_cols_size();
}
inline void VacuumRelation::clear_va_cols() {
  va_cols_.Clear();
}
inline ::pg_query::Node* VacuumRelation::mutable_va_cols(int index) {
  // @@protoc_insertion_point(field_mutable:pg_query.VacuumRelation.va_cols)
  return va_cols_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >*
VacuumRelation::mutable_va_cols() {
  // @@protoc_insertion_point(field_mutable_list:pg_query.VacuumRelation.va_cols)
  return &va_cols_;
}
inline const ::pg_query::Node& VacuumRelation::_internal_va_cols(int index) const {
  return va_cols_.Get(index);
}
inline const ::pg_query::Node& VacuumRelation::va_cols(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.VacuumRelation.va_cols)
  return _internal_va_cols(index);
}
inline ::pg_query::Node* VacuumRelation::_internal_add_va_cols() {
  return va_cols_.Add();
}
inline ::pg_query::Node* VacuumRelation::add_va_cols() {
  // @@protoc_insertion_point(field_add:pg_query.VacuumRelation.va_cols)
  return _internal_add_va_cols();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >&
VacuumRelation::va_cols() const {
  // @@protoc_insertion_point(field_list:pg_query.VacuumRelation.va_cols)
  return va_cols_;
}

// -------------------------------------------------------------------

// InlineCodeBlock

// string source_text = 1 [json_name = "source_text"];
inline void InlineCodeBlock::clear_source_text() {
  source_text_.ClearToEmpty();
}
inline const std::string& InlineCodeBlock::source_text() const {
  // @@protoc_insertion_point(field_get:pg_query.InlineCodeBlock.source_text)
  return _internal_source_text();
}
inline void InlineCodeBlock::set_source_text(const std::string& value) {
  _internal_set_source_text(value);
  // @@protoc_insertion_point(field_set:pg_query.InlineCodeBlock.source_text)
}
inline std::string* InlineCodeBlock::mutable_source_text() {
  // @@protoc_insertion_point(field_mutable:pg_query.InlineCodeBlock.source_text)
  return _internal_mutable_source_text();
}
inline const std::string& InlineCodeBlock::_internal_source_text() const {
  return source_text_.Get();
}
inline void InlineCodeBlock::_internal_set_source_text(const std::string& value) {
  
  source_text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void InlineCodeBlock::set_source_text(std::string&& value) {
  
  source_text_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pg_query.InlineCodeBlock.source_text)
}
inline void InlineCodeBlock::set_source_text(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  source_text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pg_query.InlineCodeBlock.source_text)
}
inline void InlineCodeBlock::set_source_text(const char* value,
    size_t size) {
  
  source_text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pg_query.InlineCodeBlock.source_text)
}
inline std::string* InlineCodeBlock::_internal_mutable_source_text() {
  
  return source_text_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* InlineCodeBlock::release_source_text() {
  // @@protoc_insertion_point(field_release:pg_query.InlineCodeBlock.source_text)
  return source_text_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void InlineCodeBlock::set_allocated_source_text(std::string* source_text) {
  if (source_text != nullptr) {
    
  } else {
    
  }
  source_text_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source_text,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pg_query.InlineCodeBlock.source_text)
}

// uint32 lang_oid = 2 [json_name = "langOid"];
inline void InlineCodeBlock::clear_lang_oid() {
  lang_oid_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 InlineCodeBlock::_internal_lang_oid() const {
  return lang_oid_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 InlineCodeBlock::lang_oid() const {
  // @@protoc_insertion_point(field_get:pg_query.InlineCodeBlock.lang_oid)
  return _internal_lang_oid();
}
inline void InlineCodeBlock::_internal_set_lang_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  lang_oid_ = value;
}
inline void InlineCodeBlock::set_lang_oid(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_lang_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.InlineCodeBlock.lang_oid)
}

// bool lang_is_trusted = 3 [json_name = "langIsTrusted"];
inline void InlineCodeBlock::clear_lang_is_trusted() {
  lang_is_trusted_ = false;
}
inline bool InlineCodeBlock::_internal_lang_is_trusted() const {
  return lang_is_trusted_;
}
inline bool InlineCodeBlock::lang_is_trusted() const {
  // @@protoc_insertion_point(field_get:pg_query.InlineCodeBlock.lang_is_trusted)
  return _internal_lang_is_trusted();
}
inline void InlineCodeBlock::_internal_set_lang_is_trusted(bool value) {
  
  lang_is_trusted_ = value;
}
inline void InlineCodeBlock::set_lang_is_trusted(bool value) {
  _internal_set_lang_is_trusted(value);
  // @@protoc_insertion_point(field_set:pg_query.InlineCodeBlock.lang_is_trusted)
}

// bool atomic = 4 [json_name = "atomic"];
inline void InlineCodeBlock::clear_atomic() {
  atomic_ = false;
}
inline bool InlineCodeBlock::_internal_atomic() const {
  return atomic_;
}
inline bool InlineCodeBlock::atomic() const {
  // @@protoc_insertion_point(field_get:pg_query.InlineCodeBlock.atomic)
  return _internal_atomic();
}
inline void InlineCodeBlock::_internal_set_atomic(bool value) {
  
  atomic_ = value;
}
inline void InlineCodeBlock::set_atomic(bool value) {
  _internal_set_atomic(value);
  // @@protoc_insertion_point(field_set:pg_query.InlineCodeBlock.atomic)
}

// -------------------------------------------------------------------

// CallContext

// bool atomic = 1 [json_name = "atomic"];
inline void CallContext::clear_atomic() {
  atomic_ = false;
}
inline bool CallContext::_internal_atomic() const {
  return atomic_;
}
inline bool CallContext::atomic() const {
  // @@protoc_insertion_point(field_get:pg_query.CallContext.atomic)
  return _internal_atomic();
}
inline void CallContext::_internal_set_atomic(bool value) {
  
  atomic_ = value;
}
inline void CallContext::set_atomic(bool value) {
  _internal_set_atomic(value);
  // @@protoc_insertion_point(field_set:pg_query.CallContext.atomic)
}

// -------------------------------------------------------------------

// ScanToken

// int32 start = 1;
inline void ScanToken::clear_start() {
  start_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ScanToken::_internal_start() const {
  return start_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ScanToken::start() const {
  // @@protoc_insertion_point(field_get:pg_query.ScanToken.start)
  return _internal_start();
}
inline void ScanToken::_internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  start_ = value;
}
inline void ScanToken::set_start(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_start(value);
  // @@protoc_insertion_point(field_set:pg_query.ScanToken.start)
}

// int32 end = 2;
inline void ScanToken::clear_end() {
  end_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ScanToken::_internal_end() const {
  return end_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ScanToken::end() const {
  // @@protoc_insertion_point(field_get:pg_query.ScanToken.end)
  return _internal_end();
}
inline void ScanToken::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  end_ = value;
}
inline void ScanToken::set_end(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_end(value);
  // @@protoc_insertion_point(field_set:pg_query.ScanToken.end)
}

// .pg_query.Token token = 4;
inline void ScanToken::clear_token() {
  token_ = 0;
}
inline ::pg_query::Token ScanToken::_internal_token() const {
  return static_cast< ::pg_query::Token >(token_);
}
inline ::pg_query::Token ScanToken::token() const {
  // @@protoc_insertion_point(field_get:pg_query.ScanToken.token)
  return _internal_token();
}
inline void ScanToken::_internal_set_token(::pg_query::Token value) {
  
  token_ = value;
}
inline void ScanToken::set_token(::pg_query::Token value) {
  _internal_set_token(value);
  // @@protoc_insertion_point(field_set:pg_query.ScanToken.token)
}

// .pg_query.KeywordKind keyword_kind = 5;
inline void ScanToken::clear_keyword_kind() {
  keyword_kind_ = 0;
}
inline ::pg_query::KeywordKind ScanToken::_internal_keyword_kind() const {
  return static_cast< ::pg_query::KeywordKind >(keyword_kind_);
}
inline ::pg_query::KeywordKind ScanToken::keyword_kind() const {
  // @@protoc_insertion_point(field_get:pg_query.ScanToken.keyword_kind)
  return _internal_keyword_kind();
}
inline void ScanToken::_internal_set_keyword_kind(::pg_query::KeywordKind value) {
  
  keyword_kind_ = value;
}
inline void ScanToken::set_keyword_kind(::pg_query::KeywordKind value) {
  _internal_set_keyword_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.ScanToken.keyword_kind)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace pg_query

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::pg_query::OverridingKind> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::OverridingKind>() {
  return ::pg_query::OverridingKind_descriptor();
}
template <> struct is_proto_enum< ::pg_query::QuerySource> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::QuerySource>() {
  return ::pg_query::QuerySource_descriptor();
}
template <> struct is_proto_enum< ::pg_query::SortByDir> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::SortByDir>() {
  return ::pg_query::SortByDir_descriptor();
}
template <> struct is_proto_enum< ::pg_query::SortByNulls> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::SortByNulls>() {
  return ::pg_query::SortByNulls_descriptor();
}
template <> struct is_proto_enum< ::pg_query::A_Expr_Kind> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::A_Expr_Kind>() {
  return ::pg_query::A_Expr_Kind_descriptor();
}
template <> struct is_proto_enum< ::pg_query::RoleSpecType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::RoleSpecType>() {
  return ::pg_query::RoleSpecType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::TableLikeOption> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::TableLikeOption>() {
  return ::pg_query::TableLikeOption_descriptor();
}
template <> struct is_proto_enum< ::pg_query::DefElemAction> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::DefElemAction>() {
  return ::pg_query::DefElemAction_descriptor();
}
template <> struct is_proto_enum< ::pg_query::PartitionRangeDatumKind> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::PartitionRangeDatumKind>() {
  return ::pg_query::PartitionRangeDatumKind_descriptor();
}
template <> struct is_proto_enum< ::pg_query::RTEKind> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::RTEKind>() {
  return ::pg_query::RTEKind_descriptor();
}
template <> struct is_proto_enum< ::pg_query::WCOKind> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::WCOKind>() {
  return ::pg_query::WCOKind_descriptor();
}
template <> struct is_proto_enum< ::pg_query::GroupingSetKind> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::GroupingSetKind>() {
  return ::pg_query::GroupingSetKind_descriptor();
}
template <> struct is_proto_enum< ::pg_query::CTEMaterialize> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::CTEMaterialize>() {
  return ::pg_query::CTEMaterialize_descriptor();
}
template <> struct is_proto_enum< ::pg_query::SetOperation> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::SetOperation>() {
  return ::pg_query::SetOperation_descriptor();
}
template <> struct is_proto_enum< ::pg_query::ObjectType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::ObjectType>() {
  return ::pg_query::ObjectType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::DropBehavior> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::DropBehavior>() {
  return ::pg_query::DropBehavior_descriptor();
}
template <> struct is_proto_enum< ::pg_query::AlterTableType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::AlterTableType>() {
  return ::pg_query::AlterTableType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::GrantTargetType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::GrantTargetType>() {
  return ::pg_query::GrantTargetType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::VariableSetKind> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::VariableSetKind>() {
  return ::pg_query::VariableSetKind_descriptor();
}
template <> struct is_proto_enum< ::pg_query::ConstrType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::ConstrType>() {
  return ::pg_query::ConstrType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::ImportForeignSchemaType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::ImportForeignSchemaType>() {
  return ::pg_query::ImportForeignSchemaType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::RoleStmtType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::RoleStmtType>() {
  return ::pg_query::RoleStmtType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::FetchDirection> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::FetchDirection>() {
  return ::pg_query::FetchDirection_descriptor();
}
template <> struct is_proto_enum< ::pg_query::FunctionParameterMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::FunctionParameterMode>() {
  return ::pg_query::FunctionParameterMode_descriptor();
}
template <> struct is_proto_enum< ::pg_query::TransactionStmtKind> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::TransactionStmtKind>() {
  return ::pg_query::TransactionStmtKind_descriptor();
}
template <> struct is_proto_enum< ::pg_query::ViewCheckOption> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::ViewCheckOption>() {
  return ::pg_query::ViewCheckOption_descriptor();
}
template <> struct is_proto_enum< ::pg_query::ClusterOption> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::ClusterOption>() {
  return ::pg_query::ClusterOption_descriptor();
}
template <> struct is_proto_enum< ::pg_query::DiscardMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::DiscardMode>() {
  return ::pg_query::DiscardMode_descriptor();
}
template <> struct is_proto_enum< ::pg_query::ReindexObjectType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::ReindexObjectType>() {
  return ::pg_query::ReindexObjectType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::AlterTSConfigType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::AlterTSConfigType>() {
  return ::pg_query::AlterTSConfigType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::AlterSubscriptionType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::AlterSubscriptionType>() {
  return ::pg_query::AlterSubscriptionType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::OnCommitAction> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::OnCommitAction>() {
  return ::pg_query::OnCommitAction_descriptor();
}
template <> struct is_proto_enum< ::pg_query::ParamKind> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::ParamKind>() {
  return ::pg_query::ParamKind_descriptor();
}
template <> struct is_proto_enum< ::pg_query::CoercionContext> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::CoercionContext>() {
  return ::pg_query::CoercionContext_descriptor();
}
template <> struct is_proto_enum< ::pg_query::CoercionForm> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::CoercionForm>() {
  return ::pg_query::CoercionForm_descriptor();
}
template <> struct is_proto_enum< ::pg_query::BoolExprType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::BoolExprType>() {
  return ::pg_query::BoolExprType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::SubLinkType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::SubLinkType>() {
  return ::pg_query::SubLinkType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::RowCompareType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::RowCompareType>() {
  return ::pg_query::RowCompareType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::MinMaxOp> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::MinMaxOp>() {
  return ::pg_query::MinMaxOp_descriptor();
}
template <> struct is_proto_enum< ::pg_query::SQLValueFunctionOp> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::SQLValueFunctionOp>() {
  return ::pg_query::SQLValueFunctionOp_descriptor();
}
template <> struct is_proto_enum< ::pg_query::XmlExprOp> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::XmlExprOp>() {
  return ::pg_query::XmlExprOp_descriptor();
}
template <> struct is_proto_enum< ::pg_query::XmlOptionType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::XmlOptionType>() {
  return ::pg_query::XmlOptionType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::NullTestType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::NullTestType>() {
  return ::pg_query::NullTestType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::BoolTestType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::BoolTestType>() {
  return ::pg_query::BoolTestType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::CmdType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::CmdType>() {
  return ::pg_query::CmdType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::JoinType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::JoinType>() {
  return ::pg_query::JoinType_descriptor();
}
template <> struct is_proto_enum< ::pg_query::AggStrategy> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::AggStrategy>() {
  return ::pg_query::AggStrategy_descriptor();
}
template <> struct is_proto_enum< ::pg_query::AggSplit> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::AggSplit>() {
  return ::pg_query::AggSplit_descriptor();
}
template <> struct is_proto_enum< ::pg_query::SetOpCmd> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::SetOpCmd>() {
  return ::pg_query::SetOpCmd_descriptor();
}
template <> struct is_proto_enum< ::pg_query::SetOpStrategy> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::SetOpStrategy>() {
  return ::pg_query::SetOpStrategy_descriptor();
}
template <> struct is_proto_enum< ::pg_query::OnConflictAction> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::OnConflictAction>() {
  return ::pg_query::OnConflictAction_descriptor();
}
template <> struct is_proto_enum< ::pg_query::LimitOption> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::LimitOption>() {
  return ::pg_query::LimitOption_descriptor();
}
template <> struct is_proto_enum< ::pg_query::LockClauseStrength> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::LockClauseStrength>() {
  return ::pg_query::LockClauseStrength_descriptor();
}
template <> struct is_proto_enum< ::pg_query::LockWaitPolicy> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::LockWaitPolicy>() {
  return ::pg_query::LockWaitPolicy_descriptor();
}
template <> struct is_proto_enum< ::pg_query::LockTupleMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::LockTupleMode>() {
  return ::pg_query::LockTupleMode_descriptor();
}
template <> struct is_proto_enum< ::pg_query::KeywordKind> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::KeywordKind>() {
  return ::pg_query::KeywordKind_descriptor();
}
template <> struct is_proto_enum< ::pg_query::Token> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::Token>() {
  return ::pg_query::Token_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protobuf_2fpg_5fquery_2eproto
